...
Pregătire interviuri

100 de întrebări de interviu pentru Android Developer, cu răspunsuri

Întrebările care apar des la interviurile de Android Developer, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 34mid
  • 16senior
  • 146 minde citit
Întrebări de interviu Android Developer cu răspunsuri

Un interviu pentru un post de Android Developer are de obicei câteva etape: o discuție inițială cu cineva din HR sau cu un recruiter, în care se verifică motivația, disponibilitatea și așteptările, apoi unul sau două interviuri tehnice. În partea tehnică vei primi întrebări despre Kotlin, ciclul de viață al componentelor Android, Jetpack Compose, arhitectura aplicației și lucrul cu date și rețea. Multe firme adaugă o temă de casă (o aplicație mică ce citește date dintr-un API și le afișează într-o listă) sau un exercițiu live, în care scrii cod și explici cu voce tare ce faci.

La nivel junior, intervievatorul urmărește dacă înțelegi fundamentele: null safety, Activity și Fragment, de ce există ViewModel, cum faci un request cu Retrofit și cum salvezi date local cu Room. Nu se așteaptă să știi totul, ci să gândești corect și să recunoști când nu știi. La nivel mid se pune accent pe coroutines și Flow, pe arhitectură (MVVM, injectare de dependențe cu Hilt), pe testare și pe deciziile pe care le-ai luat în proiecte reale. La senior discuția trece spre modularizare, performanță, strategii offline-first și felul în care ajuți echipa.

Pagina e organizată pe teme, iar în fiecare temă întrebările merg de la junior la senior. Citește întâi răspunsul scurt și încearcă să formulezi singur explicația, apoi compară cu răspunsul detaliat. Rulează exemplele de cod într-un proiect Android Studio: le vei ține minte mult mai bine decât dacă doar le citești. Întrebările comportamentale de la final au un model de răspuns structurat pe care îl poți adapta la experiența ta.

Limbajul Kotlin

1 Junior

Care este diferența dintre val, var și const val în Kotlin?

Răspuns scurt: val declară o referință care nu poate fi reasignată, var una care poate fi reasignată, iar const val este o constantă cunoscută la compilare, permisă doar pentru tipuri primitive și String, la nivel de top sau în object.

val înseamnă „read-only reference”: după inițializare nu mai poți atribui altă valoare variabilei. Atenție, asta nu face obiectul imuabil. Un val list = mutableListOf(1, 2) poate primi elemente noi cu list.add(3), doar că list nu poate arăta spre altă listă.

var permite reasignarea. Regula bună în Kotlin este să folosești val implicit și var doar când chiar ai nevoie, pentru că un cod cu mai puține stări modificabile e mai ușor de urmărit și mai sigur când rulează pe mai multe thread-uri.

const val e diferit: valoarea e cunoscută la compilare și e copiată direct în locurile unde e folosită (inlining). Funcționează doar pentru tipuri primitive și String și doar la nivel de fișier (top-level), în object sau în companion object.

KOTLIN
const val BASE_URL = "https://api.exemplu.ro/"

class Cart {
    val items = mutableListOf<String>()  // referința fixă, conținutul se schimbă
    var discount = 0                     // se poate reasigna
}

Un val poate avea și un getter custom care calculează altă valoare la fiecare acces, deci „val” nu garantează nici măcar că citirile returnează mereu același lucru.

Ce urmărește intervievatorul: Se verifică dacă știi că val nu înseamnă obiect imuabil. Greșeala tipică este să spui că un val cu o listă mutabilă nu se mai poate schimba.

2 Junior

Cum funcționează null safety în Kotlin? Explică operatorii ?., ?: și !!.

Răspuns scurt: Sistemul de tipuri separă tipurile care pot fi null (String?) de cele care nu pot (String). ?. apelează doar dacă valoarea nu e null, ?: oferă o valoare implicită, iar !! forțează și aruncă NullPointerException dacă e null.

În Kotlin, nullabilitatea face parte din tip. O variabilă String nu poate primi null, compilatorul nu te lasă. Ca să permiți null, scrii String?, iar atunci compilatorul te obligă să tratezi cazul înainte să folosești valoarea. Astfel o mare parte din erorile NullPointerException sunt prinse la compilare, nu în producție.

  • ?. (safe call): user?.name returnează name dacă user nu e null, altfel null.
  • ?: (operatorul Elvis): user?.name ?: "Anonim" oferă o valoare de rezervă. Poți pune și return sau throw în dreapta.
  • !! (not-null assertion): user!!.name spune compilatorului „știu eu că nu e null”. Dacă greșești, aplicația crapă.
KOTLIN
fun greeting(user: User?): String {
    val name = user?.profile?.displayName ?: return "Salut!"
    return "Salut, $name!"
}

Mai există smart cast: după if (user != null), compilatorul tratează user ca User în interiorul blocului (pentru variabile locale sau val fără getter custom). Pentru valori venite din Java, Kotlin folosește „platform types” (String!), unde verificarea cade în sarcina ta. În cod de producție, !! ar trebui să fie rar și justificat; de obicei e semnul că modelul de date nu e gândit bine.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că folosești null safety ca instrument de design, nu că pui !! peste tot ca să tacă compilatorul.

3 Junior

Ce este o data class și ce primești automat când o declari?

Răspuns scurt: O data class e o clasă făcută pentru a ține date. Compilatorul generează automat equals(), hashCode(), toString(), copy() și funcțiile componentN() pe baza proprietăților din constructorul primar.

Într-o aplicație Android ai multe clase care doar transportă date: un răspuns de la API, o entitate din baza de date, starea unui ecran. Pentru ele, Kotlin oferă data class, care îți scutește scrierea manuală a codului repetitiv.

KOTLIN
data class Product(val id: Long, val name: String, val price: Double)

val a = Product(1, "Laptop", 3500.0)
val b = a.copy(price = 3200.0)
println(a == b)        // false, compară pe valori
println(a)             // Product(id=1, name=Laptop, price=3500.0)
val (id, name) = a     // destructurare cu component1(), component2()

Ce primești:

  • equals() și hashCode() care compară valorile proprietăților, nu referințele;
  • toString() lizibil, util în log-uri;
  • copy() care creează o copie cu unele câmpuri modificate, ideal pentru stări imuabile;
  • componentN() pentru destructurare.

Reguli: constructorul primar trebuie să aibă cel puțin un parametru, toți marcați val sau var, iar clasa nu poate fi abstract, open, sealed sau inner. Important: doar proprietățile din constructorul primar intră în equals() și toString(). Ce declari în corpul clasei e ignorat. Și copy() e o copie superficială (shallow): dacă o proprietate e o listă mutabilă, ambele obiecte vor împărți aceeași listă.

Ce urmărește intervievatorul: Se verifică dacă știi de ce copy() contează pentru stări imuabile în UI și dacă știi că proprietățile din corpul clasei nu intră în equals().

4 Junior

Cum folosești when în Kotlin și de ce e mai puternic decât un switch din Java?

Răspuns scurt: when poate fi folosit ca instrucțiune sau ca expresie care returnează o valoare, acceptă valori, intervale, verificări de tip și condiții arbitrare, iar cu sealed sau enum compilatorul verifică exhaustivitatea.

when înlocuiește switch, dar face mult mai mult. Cel mai important: e o expresie, deci întoarce o valoare pe care o poți atribui direct.

KOTLIN
fun label(code: Int): String = when (code) {
    200 -> "OK"
    in 400..499 -> "Eroare client"
    in 500..599 -> "Eroare server"
    else -> "Necunoscut"
}

fun describe(x: Any): String = when (x) {
    is String -> "Text de ${x.length} caractere"  // smart cast
    is Int -> "Număr"
    else -> "Altceva"
}

Ce poate face:

  • ramuri cu mai multe valori: 1, 2 -> ...;
  • intervale cu in și verificări de tip cu is, după care variabila e convertită automat (smart cast);
  • when fără argument, unde fiecare ramură e o condiție booleană, practic un if-else if mai curat;
  • nu există „fall-through”, deci nu uiți break.

Când when e folosit ca expresie pe un enum sau pe o sealed class, compilatorul cere ca toate cazurile să fie acoperite. Dacă adaugi mai târziu un subtip nou, codul nu mai compilează până nu tratezi cazul. Pe Android, asta e foarte util pentru stări de ecran (Loading, Success, Error). De aceea e bine să eviți else pe tipuri sealed: ai pierde exact această verificare.

Ce urmărește intervievatorul: Intervievatorul caută legătura dintre when exhaustiv și sealed class. Mulți candidați pun else și pierd verificarea compilatorului.

5 Junior

Ce sunt extension functions și când le-ai folosi?

Răspuns scurt: O extension function adaugă o funcție nouă unui tip existent fără să-l moștenești sau să-i modifici codul. Se rezolvă static la compilare și nu are acces la membrii privați ai clasei.

Cu o extension function poți scrie "abc".isValidEmail() chiar dacă String nu e clasa ta. Sintaxa pune tipul extins (receiver) înaintea numelui funcției:

KOTLIN
fun String.isValidEmail(): Boolean =
    android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()

fun Context.toast(msg: String) =
    Toast.makeText(this, msg, Toast.LENGTH_SHORT).show()

În interior, this e obiectul pe care s-a apelat funcția. În spate, compilatorul generează o funcție statică ce primește receiver-ul ca prim parametru. De aici vin două consecințe importante:

  • nu ai acces la membrii private sau protected ai clasei;
  • rezolvarea e statică, după tipul declarat, nu după tipul real la rulare. Dacă ai o extensie pe Animal și una pe Dog, iar variabila e declarată Animal, se apelează varianta pentru Animal, chiar dacă obiectul e Dog.
  • dacă clasa are deja o funcție membru cu aceeași semnătură, membrul câștigă.

Pe Android, extensiile sunt peste tot: biblioteca core-ktx și multe biblioteci Jetpack sunt construite pe ele. Le folosești pentru utilitare legate clar de un tip (formatare de date, conversii între modele). Nu exagera: o extensie pe Any sau pe String cu logică de business ajunge să polueze autocompletarea în tot proiectul.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că extensiile sunt rezolvate static. Întrebarea de follow-up clasică e exemplul cu Animal și Dog.

6 Junior

Care e diferența dintre lateinit și by lazy?

Răspuns scurt: lateinit var amână inițializarea unei proprietăți mutabile non-null pe care o setezi tu mai târziu; by lazy creează un val calculat o singură dată, la primul acces, de funcția pe care o dai.

Ambele rezolvă problema „am nevoie de o proprietate non-null, dar nu o pot inițializa în constructor”, însă în feluri diferite.

lateinit var promite compilatorului că vei atribui valoarea înainte să o citești. Funcționează doar cu var, doar pentru tipuri non-null și nu pentru tipuri primitive (Int, Boolean). Dacă citești înainte de inițializare, primești UninitializedPropertyAccessException. Poți verifica cu ::binding.isInitialized. E tipic pentru valori setate de framework sau de tine într-un callback, de exemplu un binding în onCreate.

by lazy e un delegat pentru val: dai o lambda care rulează la primul acces, rezultatul se memorează și se returnează la accesările următoare. Implicit e thread-safe (modul SYNCHRONIZED).

KOTLIN
class ProfileActivity : AppCompatActivity() {
    private lateinit var binding: ActivityProfileBinding
    private val formatter by lazy { DateTimeFormatter.ofPattern("dd.MM.yyyy") }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityProfileBinding.inflate(layoutInflater)
        setContentView(binding.root)
    }
}

Regula practică: lateinit când valoarea vine din exterior la un moment pe care îl controlezi, lazy când valoarea e scumpă de calculat și vrei să o creezi doar dacă e nevoie. Atenție la lazy cu referințe la Context sau la view-uri într-un Fragment: valoarea rămâne memorată și după ce view-ul a fost distrus.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi restricțiile (var, non-primitiv pentru lateinit; val pentru lazy) și riscurile fiecăruia.

7 Junior

Ce este un object și ce este un companion object în Kotlin?

Răspuns scurt: object declară un singleton creat leneș și thread-safe la primul acces. companion object e un obiect legat de o clasă, prin care membrii se apelează pe numele clasei, echivalentul aproximativ al membrilor static din Java.

Kotlin nu are cuvântul static. În schimb are object.

O declarație object creează o clasă cu o singură instanță. Inițializarea are loc la primul acces și e thread-safe, garantat de JVM.

KOTLIN
object Analytics {
    fun log(event: String) { /* ... */ }
}
Analytics.log("login")

Un companion object trăiește în interiorul unei clase, iar membrii lui pot fi apelați prin numele clasei. E locul tipic pentru factory methods, constante sau chei:

KOTLIN
class DetailFragment : Fragment() {
    companion object {
        private const val ARG_ID = "id"
        fun newInstance(id: Long) = DetailFragment().apply {
            arguments = bundleOf(ARG_ID to id)
        }
    }
}

Diferența față de static din Java: companion object e un obiect adevărat, poate implementa interfețe și poate avea extensii. Pentru interoperabilitate cu Java, adnotarea @JvmStatic generează o metodă statică reală, iar @JvmField expune un câmp direct.

Mai există expresiile object (object : Runnable { ... }), echivalentul claselor anonime din Java.

Pe Android, ai grijă ca un object să nu țină referințe la un Activity sau la view-uri: fiind singleton, trăiește cât procesul și provoacă memory leak. Pentru dependențe partajate, într-un proiect mai mare e preferabil un singleton gestionat de Hilt, care se poate înlocui ușor în teste.

Ce urmărește intervievatorul: Se verifică dacă știi că nu există static în Kotlin și dacă recunoști riscul de memory leak al unui singleton care ține un Context.

8 Junior

Explică scope functions: let, apply, run, also și with. Când o alegi pe fiecare?

Răspuns scurt: Toate rulează un bloc de cod în contextul unui obiect. Diferă prin cum accesezi obiectul (it sau this) și prin ce returnează (obiectul sau rezultatul lambdei): apply și also returnează obiectul, let, run și with returnează rezultatul.

Cel mai simplu e să le ții minte pe două axe:

  • let: obiectul ca it, returnează rezultatul lambdei. Folosit des cu ?.: user?.let { show(it) }.
  • also: obiectul ca it, returnează obiectul. Pentru efecte secundare, cum ar fi logarea.
  • apply: obiectul ca this, returnează obiectul. Pentru configurare.
  • run: obiectul ca this, returnează rezultatul. Pentru a calcula ceva folosind membrii obiectului.
  • with(obj) { }: ca run, dar nu e extensie, primește obiectul ca parametru.
KOTLIN
val intent = Intent(context, DetailActivity::class.java).apply {
    putExtra("id", 42L)
    flags = Intent.FLAG_ACTIVITY_SINGLE_TOP
}

val length = name?.let { it.trim().length } ?: 0

val user = repository.load().also { Log.d("Repo", "Loaded $it") }

val summary = with(order) { "$id: $total lei" }

Greșeli frecvente: lanțuri lungi de let { ... }.apply { ... }.also { ... } care devin greu de citit, și apply în interiorul unei clase, unde this din lambda ascunde this-ul clasei și ajungi să modifici alt obiect decât credeai. Un if (x != null) simplu e uneori mai clar decât x?.let. Scope functions sunt pentru lizibilitate, nu un scop în sine.

Ce urmărește intervievatorul: Intervievatorul vrea să audă criteriile de alegere (it vs this, ce returnează), nu doar definițiile recitate.

9 Junior

Care e diferența dintre List și MutableList în Kotlin? Ce face map, filter și groupBy?

Răspuns scurt: List e o interfață read-only, fără metode de modificare; MutableList adaugă add, remove și altele. map transformă fiecare element, filter păstrează elementele care respectă o condiție, iar groupBy le grupează într-un Map după o cheie.

Kotlin separă la nivel de interfață colecțiile read-only de cele mutabile: List/MutableList, Set/MutableSet, Map/MutableMap. List nu înseamnă imuabilă: în spate poate fi un ArrayList pe care altcineva îl modifică. Înseamnă doar că tu, prin referința aceea, nu o poți modifica. Practica bună: expui List în afara clasei și ții MutableList privat.

Operațiile funcționale returnează colecții noi și nu modifică sursa:

KOTLIN
data class Order(val city: String, val total: Double)

val orders = listOf(
    Order("Cluj", 120.0), Order("Iași", 80.0), Order("Cluj", 40.0)
)

val totals = orders.map { it.total }                 // [120.0, 80.0, 40.0]
val big = orders.filter { it.total > 50 }            // primele două
val byCity = orders.groupBy { it.city }              // Map<String, List<Order>>
val sumByCity = byCity.mapValues { (_, l) -> l.sumOf { it.total } }
println(sumByCity)                                   // {Cluj=160.0, Iași=80.0}

Fiecare operație pe List creează o listă intermediară. Pe colecții mari, cu multe operații înlănțuite, poți folosi asSequence(), care procesează leneș element cu element și evită listele intermediare. Pentru câteva zeci de elemente, diferența nu contează și listele simple sunt mai clare. În UI-ul Compose, colecțiile din stare ar trebui să fie read-only, ca o schimbare să fie mereu o listă nouă, ușor de detectat.

Ce urmărește intervievatorul: Se verifică dacă știi că read-only nu e același lucru cu imuabil și dacă scrii fluent operații pe colecții, lucru cerut des în exercițiile live.

10 Mid

Ce este o sealed class (sau sealed interface) și când o preferi unui enum?

Răspuns scurt: O clasă sealed are un set închis de subclase, cunoscute la compilare, fiecare putând avea propriile date. Un enum are un set fix de instanțe cu aceeași structură. Alegi sealed când variantele poartă date diferite, cum ar fi stările unui ecran.

Un enum e potrivit când ai un număr fix de valori simple: enum class Theme { LIGHT, DARK, SYSTEM }. Fiecare constantă e o singură instanță și toate au aceleași proprietăți.

O sealed class sau sealed interface restrânge moștenirea: subclasele directe trebuie declarate în același pachet și același modul. Asta îi permite compilatorului să știe toate variantele, deci un when pe ea poate fi exhaustiv. Spre deosebire de enum, fiecare variantă poate avea date proprii și pot exista mai multe instanțe.

KOTLIN
sealed interface UiState {
    data object Loading : UiState
    data class Success(val items: List<Product>) : UiState
    data class Error(val message: String, val canRetry: Boolean) : UiState
}

fun render(state: UiState) = when (state) {
    UiState.Loading -> showSpinner()
    is UiState.Success -> showList(state.items)
    is UiState.Error -> showError(state.message, state.canRetry)
}

data object (stabil din Kotlin 1.9) oferă un toString() frumos pentru variantele fără date. sealed interface (Kotlin 1.5+) e mai flexibilă, pentru că o clasă poate implementa mai multe interfețe sealed.

Folosiri tipice pe Android: stări de ecran, rezultate de operații (Success/Failure), evenimente din UI trimise spre ViewModel. Avantajul real apare la evoluția codului: când adaugi o variantă nouă, compilatorul îți arată fiecare when care trebuie actualizat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să modelezi starea unui ecran cu tipuri. Greșeala tipică e un enum plus câmpuri nullable care nu au sens pentru fiecare stare.

11 Mid

Ce face cuvântul cheie inline și ce înseamnă reified?

Răspuns scurt: inline copiază corpul funcției și lambdele primite la locul apelului, eliminând costul obiectelor lambda. reified, permis doar în funcții inline, păstrează tipul generic la rulare, ca să poți scrie T::class sau is T.

În Kotlin, o lambda transmisă unei funcții normale devine un obiect (o instanță a unei interfețe funcționale). Pentru funcții apelate foarte des, cum sunt map, filter sau let, asta ar însemna multe alocări. Marcând funcția inline, compilatorul înlocuiește apelul cu corpul funcției și al lambdei, deci nu se mai creează obiecte.

Un efect secundar util: într-o lambda inline poți folosi return simplu, care iese din funcția exterioară (non-local return). De aceea poți scrie return în forEach.

Pe JVM, tipurile generice sunt șterse la rulare (type erasure): într-o funcție fun <T> parse() nu poți afla ce e T. Cu inline plus reified, tipul concret e cunoscut la fiecare loc de apel, pentru că funcția e copiată acolo:

KOTLIN
inline fun <reified T : Activity> Context.startActivity() {
    startActivity(Intent(this, T::class.java))
}

inline fun <reified T> List<Any>.firstOfType(): T? =
    firstOrNull { it is T } as T?

// apel
context.startActivity<SettingsActivity>()

Există și noinline, pentru o lambda care trebuie păstrată ca obiect (de exemplu o salvezi într-o proprietate), și crossinline, care interzice return non-local când lambda rulează în alt context.

Nu marca orice funcție inline: dacă e mare și apelată din multe locuri, crește dimensiunea bytecode-ului. Beneficiul apare în special pentru funcții mici care primesc lambde.

Ce urmărește intervievatorul: Se verifică înțelegerea type erasure și a costului lambdelor. Mulți candidați știu că reified există, dar nu pot explica de ce cere inline.

12 Mid

Ce afișează codul următor și de ce?

KOTLIN
data class Point(val x: Int, val y: Int)

fun main() {
    val a = Point(1, 2)
    val b = Point(1, 2)
    val c = a
    println(a == b)
    println(a === b)
    println(a === c)
    val set = hashSetOf(a, b, c)
    println(set.size)
}

Răspuns scurt: Afișează true, false, true și 1. == apelează equals(), care la data class compară valorile; === compară referințele; setul păstrează un singur element pentru că toate trei sunt egale și au același hashCode().

În Kotlin există două feluri de egalitate:

  • == este egalitate structurală. Se traduce în a?.equals(b) ?: (b === null), deci e și null-safe. Pentru o data class, equals() generat compară x și y. a == b dă true.
  • === este egalitate referențială: verifică dacă ambele variabile arată spre același obiect din memorie. a și b sunt create separat, deci a === b dă false. c = a copiază doar referința, deci a === c dă true.
true
false
true
1

HashSet folosește hashCode() ca să găsească „cutia” și apoi equals() ca să decidă dacă elementul există deja. Pentru că data class generează ambele metode pe baza acelorași câmpuri, cele trei obiecte sunt considerate același element, iar mărimea setului e 1.

Dacă Point ar fi o clasă obișnuită (fără data), equals() ar fi cel moștenit din Any, care compară referințe. Atunci rezultatul ar fi false, false, true și setul ar avea 2 elemente (a/c și b).

Pe Android, asta contează direct: Compose și DiffUtil din RecyclerView folosesc equals() ca să decidă dacă un element s-a schimbat. Dacă suprascrii manual doar equals() fără hashCode(), colecțiile bazate pe hash se comportă greșit.

Ce urmărește intervievatorul: Intervievatorul verifică distincția ==/=== și contractul equals/hashCode. Varianta cu clasă non-data e un follow-up frecvent.

13 Mid

Ce înseamnă in și out la generice în Kotlin (variance)?

Răspuns scurt: out T face tipul covariant: clasa doar produce valori T, deci List<Dog> poate fi folosit ca List<Animal>. in T îl face contravariant: clasa doar consumă T, deci un Comparator<Animal> poate fi folosit ca Comparator<Dog>.

Implicit, genericele sunt invariante: chiar dacă Dog e subtip de Animal, MutableList<Dog> nu e subtip de MutableList<Animal>. Altfel ai putea face animals.add(Cat()) într-o listă care de fapt conține doar câini.

Variance la declarare (declaration-site variance) rezolvă cazurile sigure:

  • out T (covarianță): T apare doar în poziții de ieșire, ca tip returnat. interface List<out E> din Kotlin e declarată așa, de aceea List<Dog> se poate da unei funcții care cere List<Animal>. E sigur, pentru că poți doar citi.
  • in T (contravarianță): T apare doar ca parametru. Comparable<in T> permite ca un comparator de Animal să fie folosit pentru Dog.
KOTLIN
interface Producer<out T> { fun produce(): T }
interface Consumer<in T> { fun consume(item: T) }

fun feedAll(animals: List<Animal>) { /* ... */ }
val dogs: List<Dog> = listOf(Dog())
feedAll(dogs)          // compilează datorită lui out

fun copy(from: Array<out Any>, to: Array<Any>) { /* ... */ }  // use-site variance

Variance la utilizare (use-site), ca în Array<out Any>, e echivalentul lui ? extends din Java, iar in corespunde lui ? super. Star projection (List<*>) înseamnă „o listă de ceva, nu știu ce”, din care poți citi doar Any?.

În practică pe Android vei vedea asta în semnături ca Flow<out T> sau când scrii un adapter generic. Regula de memorat e „producer out, consumer in”.

Ce urmărește intervievatorul: Se verifică dacă înțelegi de ce invarianța protejează de erori și dacă poți face legătura cu ? extends/? super din Java.

14 Senior

Cum funcționează delegarea în Kotlin (by) și ce probleme apar la interoperabilitatea cu Java?

Răspuns scurt: by delegă implementarea unei interfețe sau accesul la o proprietate unui alt obiect (lazy, observable, viewModels()). La interop cu Java, problemele tipice sunt platform types fără informații de nullabilitate, lipsa membrilor statici și parametrii impliciți, rezolvate cu adnotări ca @Nullable, @JvmStatic și @JvmOverloads.

Delegarea apare în două forme. Delegarea de clasă implementează o interfață trimițând apelurile unui obiect intern, o alternativă la moștenire:

KOTLIN
class LoggingList<T>(private val inner: MutableList<T>) : MutableList<T> by inner {
    override fun add(element: T): Boolean {
        Log.d("List", "add $element")
        return inner.add(element)
    }
}

Delegarea de proprietăți mută logica de get/set într-un obiect cu getValue/setValue. Pe Android o folosești zilnic: val vm: MainViewModel by viewModels(), by lazy, by remember { mutableStateOf(0) } în Compose sau Delegates.observable.

La interoperabilitate cu Java apar câteva capcane:

  • tipurile venite din Java sunt platform types (String!): Kotlin nu știe dacă pot fi null. Dacă API-ul Java nu are adnotări @Nullable/@NonNull, un null neașteptat aruncă excepție la prima utilizare. Soluția e să declari explicit tipul (val s: String? = javaObj.name).
  • Java nu vede parametrii impliciți; @JvmOverloads generează supraîncărcările.
  • membrii din companion object se apelează din Java ca Foo.Companion.bar() fără @JvmStatic.
  • funcțiile top-level ajung în clasa NumeFisierKt, redenumibilă cu @file:JvmName.
  • excepțiile verificate nu există în Kotlin; pentru apelanții Java ai nevoie de @Throws.

Într-o bază de cod mixtă, migrarea treptată spre Kotlin începe de obicei cu adnotarea nullabilității în codul Java, pentru că altfel null safety-ul Kotlin e doar aparent.

Ce urmărește intervievatorul: La senior se verifică experiența cu baze de cod mixte. Răspunsul slab se oprește la by lazy fără să atingă platform types.

Coroutines și Flow

15 Junior

Ce este o corutină și prin ce diferă de un thread?

Răspuns scurt: O corutină e o bucată de cod care se poate suspenda și relua fără să blocheze thread-ul pe care rulează. E mult mai ieftină decât un thread: mii de corutine pot împărți câteva thread-uri, iar suspendarea eliberează thread-ul pentru alte lucrări.

Un thread e o resursă a sistemului de operare: are propria stivă (de ordinul sutelor de KB până la câțiva MB), iar crearea și comutarea între thread-uri costă. Dacă blochezi un thread așteptând un răspuns de rețea, el stă degeaba.

O corutină e gestionată de biblioteca kotlinx.coroutines. Când întâlnește un punct de suspendare (de exemplu un apel suspend de rețea), își salvează starea și eliberează thread-ul. Când rezultatul e gata, corutina e reluată, posibil chiar pe alt thread din același dispatcher. Compilatorul transformă funcțiile suspend într-o mașină de stări cu un parametru ascuns Continuation.

KOTLIN
fun main() = runBlocking {
    repeat(10_000) {
        launch {
            delay(1000)   // suspendă, nu blochează
            print(".")
        }
    }
}

Codul de mai sus pornește 10.000 de corutine fără probleme; cu 10.000 de thread-uri ai consuma foarte multă memorie.

Pe Android, beneficiul principal e că poți scrie cod asincron secvențial, fără callback-uri imbricate, și poți rula lucrul pe fundal păstrând thread-ul principal liber pentru UI. Atenție la un detaliu: corutinele nu fac singure codul să ruleze în paralel sau pe alt thread. Dacă apelezi o funcție care blochează (de exemplu Thread.sleep sau un I/O sincron) pe Dispatchers.Main, UI-ul se blochează la fel ca fără corutine.

Ce urmărește intervievatorul: Se verifică diferența dintre suspendare și blocare. Greșeala tipică e să spui că o corutină „rulează pe un thread separat”.

16 Junior

Ce înseamnă o funcție suspend și de unde o poți apela?

Răspuns scurt: O funcție suspend poate să-și suspende execuția fără să blocheze thread-ul. Poate fi apelată doar dintr-o altă funcție suspend sau dintr-un constructor de corutine precum launch, async sau runBlocking.

Modificatorul suspend spune compilatorului că funcția poate face pauze. În spate, compilatorul îi adaugă un parametru Continuation, care ține minte unde trebuie reluată execuția. De aceea nu o poți apela dintr-o funcție normală: aceasta nu are de unde să ofere acel Continuation.

KOTLIN
interface UserApi {
    @GET("users/{id}")
    suspend fun getUser(@Path("id") id: Long): UserDto
}

class UserRepository(private val api: UserApi) {
    suspend fun loadName(id: Long): String {
        val user = api.getUser(id)   // suspendă aici
        return user.name             // continuă după răspuns
    }
}

// în ViewModel
fun onOpen(id: Long) {
    viewModelScope.launch {
        _name.value = repository.loadName(id)
    }
}

Câteva lucruri pe care candidații le confundă:

  • suspend nu mută automat codul pe un thread de fundal. Dacă în funcție faci un calcul greu sau un I/O blocant, trebuie să folosești withContext(Dispatchers.IO) sau Dispatchers.Default.
  • Convenția e ca o funcție suspend să fie main-safe: să poată fi apelată sigur de pe thread-ul principal. Retrofit și Room respectă asta pentru funcțiile suspend, mutând singure lucrul pe fundal.
  • O funcție nu trebuie marcată suspend dacă nu apelează nimic suspendabil; IDE-ul îți arată avertisment.

Ce urmărește intervievatorul: Intervievatorul vrea să audă că suspend nu înseamnă „pe fundal” și să vadă că știi conceptul de main-safety.

17 Junior

Care e diferența dintre launch și async?

Răspuns scurt: launch pornește o corutină „fire and forget” și returnează un Job; async pornește o corutină care produce un rezultat și returnează un Deferred<T>, din care iei valoarea cu await(). Folosești async când vrei rezultate calculate în paralel.

Ambele sunt constructori de corutine (coroutine builders) și se apelează pe un CoroutineScope.

launch e pentru lucru care nu returnează nimic direct: salvezi ceva, actualizezi o stare. Returnează un Job, pe care îl poți anula (cancel()) sau aștepta (join()).

async returnează Deferred<T>, un Job cu rezultat. Apelezi await() ca să suspenzi până e gata valoarea. Cazul clasic: două request-uri independente pe care vrei să le faci în paralel.

KOTLIN
suspend fun loadDashboard(): Dashboard = coroutineScope {
    val profile = async { api.getProfile() }
    val orders = async { api.getOrders() }
    Dashboard(profile.await(), orders.await())
}

Timpul total e aproximativ cel al request-ului mai lung, nu suma lor. Dacă ai scrie api.getProfile() și apoi api.getOrders() direct, ar rula unul după altul.

Diferențe la erori:

  • într-un launch, o excepție neprinsă se propagă imediat la părinte și, dacă nimeni nu o tratează, ajunge la handler-ul global (pe Android, crash).
  • într-un async, excepția e livrată la await(), dar în structured concurrency se propagă oricum și la părinte, anulând scope-ul.

Greșeala frecventă: async { ... }.await() imediat, pe aceeași linie. E echivalent cu un apel secvențial și nu aduce nimic în plus față de withContext.

Ce urmărește intervievatorul: Se verifică dacă știi când async aduce paralelism real și dacă recunoști anti-pattern-ul async { }.await() imediat.

18 Junior

Ce sunt Dispatchers.Main, Dispatchers.IO și Dispatchers.Default și când îl folosești pe fiecare?

Răspuns scurt: Un dispatcher decide pe ce thread-uri rulează corutina. Main e thread-ul de UI, IO e un pool pentru operații care așteaptă (rețea, fișiere, baze de date), iar Default e un pool dimensionat după numărul de nuclee, pentru calcule intensive pe CPU.

Fiecare corutină rulează într-un CoroutineContext, iar dispatcher-ul face parte din el.

  • Dispatchers.Main: thread-ul principal Android. Aici actualizezi UI-ul. viewModelScope și lifecycleScope folosesc implicit Dispatchers.Main.immediate, care execută imediat dacă ești deja pe main, fără să mai pună lucrul în coadă.
  • Dispatchers.IO: pentru operații blocante de intrare/ieșire. Are implicit o limită de 64 de thread-uri (sau numărul de nuclee, dacă e mai mare), pentru că aceste thread-uri stau mult timp în așteptare.
  • Dispatchers.Default: pentru lucru pe CPU, ca parsarea unui JSON mare, sortări, procesare de imagini. Numărul de thread-uri e egal cu numărul de nuclee (minimum 2). IO și Default împart de fapt același pool de thread-uri, cu limite diferite.

Schimbi dispatcher-ul cu withContext:

KOTLIN
class ReportRepository(private val dao: ReportDao) {
    suspend fun buildReport(): Report = withContext(Dispatchers.Default) {
        val rows = dao.getAll()          // Room suspend, deja main-safe
        rows.groupBy { it.category }     // calcul pe CPU
            .map { (k, v) -> Line(k, v.sumOf { it.amount }) }
            .let(::Report)
    }
}

O practică bună este să injectezi dispatcherele (de exemplu prin constructor sau cu Hilt) în loc să scrii Dispatchers.IO direct în cod. Așa, în teste le poți înlocui cu un TestDispatcher și controlezi timpul și ordinea execuției.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi dispatcher-ul după tipul de lucru (așteptare vs calcul) și dacă știi că nu trebuie blocat Main.

19 Mid

Ce înseamnă structured concurrency și ce rol au viewModelScope și lifecycleScope?

Răspuns scurt: Structured concurrency înseamnă că fiecare corutină pornește într-un scope, iar scope-ul își așteaptă copiii, le propagă erorile și îi anulează pe toți când e anulat. viewModelScope se anulează în onCleared(), iar lifecycleScope la distrugerea componentei, deci nu rămân corutine orfane.

Fără structură, o corutină pornită și uitată ar putea continua după ce ecranul s-a închis: face request-uri inutile, consumă baterie sau încearcă să actualizeze un UI care nu mai există. Structured concurrency impune o ierarhie părinte-copil:

  • un părinte nu se termină până nu se termină toți copiii;
  • anularea părintelui anulează toți copiii;
  • o excepție într-un copil anulează părintele și frații (cu excepția cazului în care folosești SupervisorJob).

Pe Android, scope-urile sunt legate de ciclul de viață:

  • viewModelScope (din lifecycle-viewmodel-ktx) e anulat când ViewModel-ul e distrus, adică la onCleared(). E locul potrivit pentru lucrul declanșat de ecran, care trebuie să supraviețuiască rotirii.
  • lifecycleScope e legat de un LifecycleOwner (Activity sau Fragment) și e anulat la ON_DESTROY. Într-un Fragment folosește viewLifecycleOwner.lifecycleScope pentru lucru legat de view.
KOTLIN
suspend fun syncAll() = coroutineScope {
    launch { syncContacts() }
    launch { syncMessages() }
}   // revine doar după ce ambele s-au terminat

coroutineScope { } creează un scope copil în interiorul unei funcții suspend, păstrând structura. Evită GlobalScope: corutinele din el nu au părinte, nu se anulează automat și sunt greu de testat. Pentru lucru care trebuie să continue după închiderea ecranului, soluția corectă e un scope la nivel de aplicație injectat sau WorkManager, nu GlobalScope.

Ce urmărește intervievatorul: Se verifică dacă înțelegi de ce GlobalScope e evitat și dacă alegi scope-ul potrivit pentru durata de viață a lucrului.

20 Mid

Ce afișează codul următor? Explică anularea cooperativă.

KOTLIN
fun main() = runBlocking {
    val job = launch(Dispatchers.Default) {
        var i = 0
        while (i < 5) {
            Thread.sleep(300)
            println("pas ${i++}")
        }
    }
    delay(700)
    job.cancel()
    println("anulat")
    job.join()
    println("gata")
}

Răspuns scurt: Afișează pașii 0 și 1, apoi „anulat”, apoi restul pașilor până la 4 și abia la final „gata”. Anularea în coroutines e cooperativă: bucla nu apelează nicio funcție suspend și nu verifică isActive, deci nu observă anularea.

job.cancel() doar marchează corutina ca anulată. Corutina se oprește efectiv abia când ajunge la un punct de suspendare din kotlinx.coroutines (de exemplu delay, yield, withContext), care verifică starea și aruncă CancellationException, sau când codul verifică explicit starea.

Aici bucla folosește Thread.sleep, care blochează thread-ul și nu știe nimic de corutine. Așa că după 700 ms se afișează „anulat”, dar bucla continuă, iar join() așteaptă până la final:

pas 0
pas 1
anulat
pas 2
pas 3
pas 4
gata

Ca să funcționeze anularea, ai trei variante: înlocuiești Thread.sleep cu delay, verifici while (isActive && i < 5) sau apelezi ensureActive() în buclă. Cu oricare dintre ele, ieșirea devine „pas 0”, „pas 1”, „anulat”, „gata”.

Pe Android contează mult: dacă procesezi un fișier mare într-o buclă și utilizatorul închide ecranul, viewModelScope se anulează, dar bucla ta continuă să consume CPU dacă nu cooperează.

Încă o capcană: nu prinde CancellationException cu un catch (e: Exception) generic fără să o arunci mai departe. Altfel corutina „înghite” anularea și continuă să ruleze. Pentru cod de curățenie care trebuie să ruleze și după anulare, folosește finally, iar dacă acolo ai nevoie de apeluri suspend, withContext(NonCancellable).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că anularea nu oprește forțat codul. Greșeala tipică e să răspunzi că după „anulat” se afișează direct „gata”.

21 Mid

Cum tratezi excepțiile în coroutines? Ce rol au CoroutineExceptionHandler și SupervisorJob?

Răspuns scurt: Excepțiile din launch se propagă la părinte și anulează scope-ul; le prinzi cu try/catch în corutină sau, ca ultimă plasă, cu un CoroutineExceptionHandler pe scope-ul rădăcină. SupervisorJob împiedică eșecul unui copil să-i anuleze pe ceilalți.

Regula de bază: într-o ierarhie normală, dacă un copil eșuează cu o excepție (alta decât CancellationException), părintele e anulat și odată cu el toți ceilalți copii. Excepția urcă până la rădăcină.

Cea mai clară tratare e locală, cu try/catch sau runCatching în jurul apelului care poate eșua:

KOTLIN
viewModelScope.launch {
    _state.value = try {
        UiState.Success(repository.load())
    } catch (e: IOException) {
        UiState.Error("Nu există conexiune")
    }
}

CoroutineExceptionHandler e o plasă de siguranță pentru excepții neprinse. Funcționează doar instalat pe corutina rădăcină sau pe scope (nu pe un launch copil) și doar pentru launch, nu pentru async, unde excepția e livrată la await(). Nu poți „recupera” corutina din handler, doar loga sau afișa o eroare.

SupervisorJob (sau supervisorScope { }) schimbă regula: eșecul unui copil nu-l anulează pe părinte și nici pe frați. viewModelScope folosește deja SupervisorJob, de aceea un request eșuat nu oprește celelalte corutine ale ViewModel-ului.

KOTLIN
val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main +
    CoroutineExceptionHandler { _, e -> Log.e("App", "Eroare", e) })

Greșeli frecvente: un SupervisorJob() trimis ca parametru la launch(SupervisorJob()), care rupe legătura cu părintele și strică structured concurrency, și catch (e: Exception) care înghite și CancellationException.

Ce urmărește intervievatorul: Se verifică dacă știi unde funcționează CoroutineExceptionHandler și de ce viewModelScope nu se prăbușește la un singur request eșuat.

22 Mid

Ce este un Flow în Kotlin și ce înseamnă că e „cold”?

Răspuns scurt: Flow e un flux asincron de valori emise secvențial, construit pe coroutines. E „cold”: codul din builder nu rulează până când cineva apelează collect, iar fiecare colector pornește propria execuție de la zero.

O funcție suspend returnează o singură valoare. Când ai nevoie de mai multe valori în timp (rezultate dintr-o bază de date care se actualizează, progresul unei descărcări), folosești Flow<T>.

KOTLIN
fun countdown(from: Int): Flow<Int> = flow {
    for (i in from downTo 0) {
        emit(i)
        delay(1000)
    }
}

viewModelScope.launch {
    countdown(3)
        .map { "Mai sunt $it secunde" }
        .collect { _text.value = it }
}

„Cold” înseamnă că flow { } e doar o rețetă. Nimic nu se întâmplă la creare. La fiecare collect, blocul rulează din nou. Doi colectori ai aceluiași flow Room fac două interogări separate.

Operatorii intermediari (map, filter, onEach, debounce, combine, flatMapLatest) returnează un flow nou și nu pornesc nimic. Operatorii terminali (collect, first, toList) sunt funcții suspend care pornesc colectarea.

Alte reguli utile:

  • flowOn(Dispatchers.IO) schimbă dispatcher-ul pentru partea din amonte (upstream), fără să afecteze colectorul. Nu ai voie să emiți din alt context cu withContext în interiorul lui flow { }.
  • catch { } prinde erorile din amonte, iar onCompletion { } rulează la final.
  • Room poate returna Flow<List<T>> dintr-un DAO, emițând din nou la fiecare modificare a tabelei. Asta face din Flow baza pentru un UI reactiv.

Ce urmărește intervievatorul: Intervievatorul verifică diferența cold/hot și dacă știi unde se schimbă dispatcher-ul într-un flow (flowOn, nu withContext).

23 Mid

Care sunt diferențele dintre StateFlow, SharedFlow și LiveData?

Răspuns scurt: StateFlow e un flow „hot” care ține mereu o valoare curentă și o retrimite noilor colectori; SharedFlow e un flow hot configurabil, fără valoare obligatorie, potrivit pentru evenimente. LiveData e varianta mai veche, legată de lifecycle, cu API mai limitat.

Toate trei sunt „hot”: există independent de colectori și pot avea mai mulți observatori care primesc aceleași valori.

StateFlow:

  • are mereu o valoare inițială și o valoare curentă (.value);
  • un colector nou primește imediat ultima valoare;
  • ignoră valorile egale consecutive (folosește equals()), deci e ideal pentru starea UI-ului.

SharedFlow:

  • nu are valoare obligatorie; configurezi replay (câte valori retrimite) și buffer-ul;
  • potrivit pentru evenimente sau pentru a partaja un flow rece între mai mulți colectori, cu shareIn.

LiveData:

  • face parte din Architecture Components, e conștient de lifecycle (observatorii inactivi nu primesc valori);
  • e mai simplu, dar nu are operatorii bogați ai Flow-ului și e legat de Android, deci mai greu de folosit în straturile de domeniu.
KOTLIN
class SearchViewModel(repo: Repo) : ViewModel() {
    private val _query = MutableStateFlow("")
    val results: StateFlow<List<Item>> = _query
        .debounce(300)
        .flatMapLatest { repo.search(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())

    fun onQueryChange(q: String) { _query.value = q }
}

stateIn transformă un flow rece într-un StateFlow. WhileSubscribed(5_000) oprește colectarea la 5 secunde după ce nu mai are observatori, suficient cât să supraviețuiască unei rotiri fără să repornească request-ul.

În proiectele noi, recomandarea Google e Flow cu StateFlow, mai ales cu Compose; LiveData rămâne frecvent în codul existent.

Ce urmărește intervievatorul: Se verifică dacă știi să alegi tipul potrivit pentru stare versus evenimente și dacă știi ce face stateIn cu WhileSubscribed.

24 Mid

Cum colectezi corect un Flow în UI astfel încât să nu consumi resurse când aplicația e în fundal?

Răspuns scurt: În Compose folosești collectAsStateWithLifecycle(), iar în View-uri repeatOnLifecycle(Lifecycle.State.STARTED) în lifecycleScope. Ambele opresc colectarea când UI-ul nu e vizibil și o repornesc când revine.

Dacă scrii lifecycleScope.launch { viewModel.state.collect { ... } } direct în onCreate, colectarea continuă și când aplicația e în fundal (corutina e anulată abia la onDestroy). Pentru un flow de locație sau de date live, asta înseamnă baterie și rețea consumate pentru un UI pe care nu-l vede nimeni.

În sistemul de View-uri, soluția e repeatOnLifecycle:

KOTLIN
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    viewLifecycleOwner.lifecycleScope.launch {
        viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
            launch { viewModel.uiState.collect { render(it) } }
            launch { viewModel.events.collect { handle(it) } }
        }
    }
}

Blocul pornește când lifecycle-ul ajunge în STARTED și se anulează când coboară sub STARTED (la onStop). Când revii, pornește din nou.

În Compose, echivalentul e collectAsStateWithLifecycle() din lifecycle-runtime-compose:

KOTLIN
@Composable
fun ProfileRoute(viewModel: ProfileViewModel = hiltViewModel()) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()
    ProfileScreen(state)
}

Varianta collectAsState() simplă colectează cât timp composable-ul e în compoziție, inclusiv în fundal.

Combinat cu stateIn(..., SharingStarted.WhileSubscribed(5_000), ...) în ViewModel, colectarea se oprește complet în amonte când aplicația stă în fundal mai mult de câteva secunde. Mai există flowWithLifecycle, util pentru un singur flow. API-ul vechi launchWhenStarted a fost marcat deprecated, pentru că doar suspenda colectarea fără să anuleze producătorul.

Ce urmărește intervievatorul: Intervievatorul caută repeatOnLifecycle sau collectAsStateWithLifecycle. Răspunsul slab e un collect direct în lifecycleScope.launch.

25 Senior

Cum apare o race condition între corutine și cum o eviți?

Răspuns scurt: Apare când mai multe corutine care rulează pe thread-uri diferite modifică aceeași stare mutabilă fără sincronizare. O eviți cu stare confinată pe un singur thread, cu operații atomice (MutableStateFlow.update), cu Mutex sau cu un Channel/actor care serializează accesul.

Corutinele de pe Dispatchers.Default sau IO pot rula simultan pe thread-uri diferite. Orice stare mutabilă partajată are atunci aceleași probleme ca la thread-uri clasice:

KOTLIN
var counter = 0
runBlocking {
    withContext(Dispatchers.Default) {
        repeat(1000) { launch { repeat(100) { counter++ } } }
    }
}
println(counter)   // de obicei mai puțin de 100000

counter++ înseamnă citire, adunare și scriere, iar două thread-uri pot citi aceeași valoare înainte ca vreunul să scrie.

Soluții, în ordinea în care le-aș alege:

  • evită starea partajată mutabilă: fă ca fiecare corutină să returneze rezultatul și combină la final (async plus awaitAll);
  • confinare: toate modificările pe un singur thread, de exemplu Dispatchers.Main sau Dispatchers.Default.limitedParallelism(1);
  • operații atomice: AtomicInteger sau, pentru stare în ViewModel, _state.update { it.copy(count = it.count + 1) }, care face compare-and-set și reîncearcă la conflict. _state.value = _state.value.copy(...) nu e atomic;
  • Mutex cu withLock { }, echivalentul lui synchronized pentru corutine: suspendă în loc să blocheze thread-ul. Nu folosi synchronized în jurul apelurilor suspend.
KOTLIN
private val mutex = Mutex()
private var cachedToken: String? = null

suspend fun token(): String = mutex.withLock {
    cachedToken ?: api.refresh().also { cachedToken = it }
}

Exemplul cu token arată un caz real pe Android: fără Mutex, cinci request-uri care primesc simultan 401 ar declanșa cinci refresh-uri de token.

Ce urmărește intervievatorul: La senior se verifică dacă recunoști race conditions în cod realist și dacă știi că value = value.copy() nu e atomic.

26 Senior

Cum transformi un API bazat pe callback-uri (de exemplu actualizări de locație) într-un Flow?

Răspuns scurt: Folosești callbackFlow: înregistrezi callback-ul în bloc, trimiți valorile cu trySend, iar în awaitClose { } dezînregistrezi callback-ul. Pentru un singur rezultat, nu un flux, folosești suspendCancellableCoroutine.

Multe API-uri Android și din SDK-uri externe lucrează cu listener-e: locație, senzori, conectivitate, Firebase. Ca să le integrezi curat în coroutines, le împachetezi.

Pentru un flux de valori, callbackFlow:

KOTLIN
fun ConnectivityManager.networkState(): Flow<Boolean> = callbackFlow {
    val callback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) { trySend(true) }
        override fun onLost(network: Network) { trySend(false) }
    }
    registerDefaultNetworkCallback(callback)
    awaitClose { unregisterNetworkCallback(callback) }
}.distinctUntilChanged()

Detalii care contează:

  • trySend nu suspendă, deci poate fi apelat din callback-uri normale. Returnează un rezultat pe care îl poți verifica dacă buffer-ul e plin.
  • awaitClose e obligatoriu: ține blocul în viață până la anularea colectorului și e locul unde eliberezi resursa. Fără el, callbackFlow aruncă excepție, iar fără dezînregistrare ai un leak.
  • comportamentul la buffer plin se controlează cu .buffer(capacity, onBufferOverflow) sau .conflate(), care păstrează doar ultima valoare, bun pentru locație.

Pentru un singur rezultat (un API care cheamă o dată onSuccess sau onFailure), suspendCancellableCoroutine:

KOTLIN
suspend fun Task<String>.awaitResult(): String = suspendCancellableCoroutine { cont ->
    addOnSuccessListener { cont.resume(it) }
    addOnFailureListener { cont.resumeWithException(it) }
}

Folosește invokeOnCancellation pentru a opri operația dacă corutina e anulată. Biblioteca kotlinx-coroutines-play-services oferă deja await() pentru Task; verifică întâi dacă există o extensie oficială înainte să scrii una.

Ce urmărește intervievatorul: Se verifică experiența cu integrarea SDK-urilor reale. Semnalul de alarmă e lipsa lui awaitClose și deci un listener care nu se mai dezînregistrează.

Componente Android și ciclul de viață

27 Junior

Care sunt cele patru componente principale ale unei aplicații Android?

Răspuns scurt: Activity (un ecran cu care interacționează utilizatorul), Service (lucru fără interfață), BroadcastReceiver (reacție la evenimente de sistem sau din aplicație) și ContentProvider (partajarea datelor cu alte aplicații). Toate se declară în AndroidManifest.xml.

Sistemul Android pornește aplicația ta prin aceste componente, nu printr-o funcție main. Fiecare e un punct de intrare pe care sistemul îl poate activa.

  • Activity: un ecran cu UI. Cu Jetpack Compose, multe aplicații au o singură Activity care găzduiește toate ecranele. Activity-ul care pornește din launcher are un intent-filter cu MAIN și LAUNCHER.
  • Service: lucru care nu are nevoie de UI. De la Android 8 (API 26), serviciile de fundal sunt foarte restricționate. Pentru lucru vizibil utilizatorului (redare audio, navigație) folosești un foreground service cu notificare; pentru lucru amânabil, WorkManager.
  • BroadcastReceiver: primește mesaje de tip broadcast, cum ar fi „telefonul a pornit” (BOOT_COMPLETED) sau „s-a schimbat limba”. Majoritatea broadcast-urilor implicite nu mai pot fi înregistrate în manifest de la Android 8; le înregistrezi din cod, cât timp ai nevoie de ele.
  • ContentProvider: oferă o interfață standard (URI-uri, interogări) pentru date partajate. Agenda și galeria de poze sunt expuse astfel. Și unele biblioteci folosesc un ContentProvider ca să se inițializeze automat la pornire.
XML
<activity android:name=".MainActivity" android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

De la Android 12 (API 31), orice componentă cu intent-filter trebuie să declare explicit android:exported. Fragment și ViewModel nu sunt componente de sistem; sunt clase din biblioteci, gestionate de aplicație.

Ce urmărește intervievatorul: Întrebare de deschidere: se verifică fundamentele. Candidații pun des Fragment pe listă, deși nu e componentă de sistem.

28 Junior

Descrie ciclul de viață al unei Activity.

Răspuns scurt: Callback-urile principale sunt onCreate, onStart, onResume (vizibilă și interactivă), apoi onPause, onStop (nu mai e vizibilă) și onDestroy. Există și onRestart, apelat când revii la o Activity oprită.

Sistemul apelează aceste metode când Activity-ul își schimbă starea:

  • onCreate: o singură dată pe instanță. Aici setezi UI-ul (setContent sau setContentView), obții ViewModel-ul și citești savedInstanceState.
  • onStart: Activity-ul devine vizibil. Bun pentru a porni lucru legat de vizibilitate.
  • onResume: e în prim-plan și primește input. Aici pornești camera sau animațiile.
  • onPause: pierde focusul, de exemplu apare un dialog de sistem sau intri în multi-window. Trebuie să fie rapid; nu salva date mari aici.
  • onStop: nu mai e vizibil. Eliberezi resurse legate de UI și salvezi date, dacă e cazul.
  • onDestroy: instanța e distrusă, fie pentru că s-a apelat finish() sau utilizatorul a dat back, fie din cauza unei schimbări de configurație. Verifici cu isFinishing.
Pornire:      onCreate -> onStart -> onResume
Home:         onPause -> onStop
Revenire:     onRestart -> onStart -> onResume
Back:         onPause -> onStop -> onDestroy

Două lucruri importante. Primul: nu există garanția că onDestroy va fi apelat. Dacă sistemul are nevoie de memorie, poate omorî procesul cât aplicația e în fundal (după onStop), fără alte callback-uri. Deci datele importante se salvează mai devreme. Al doilea: în loc să pui mult cod direct în aceste metode, folosești componente lifecycle-aware (LifecycleObserver, repeatOnLifecycle), care reacționează singure la stări și țin codul organizat.

Ce urmărește intervievatorul: Se verifică ordinea callback-urilor și înțelegerea faptului că onDestroy nu e garantat. Un follow-up des întâlnit: ce se apelează când apeși Home.

29 Junior

Ce se întâmplă cu o Activity la rotirea ecranului și cum îți păstrezi datele?

Răspuns scurt: La o schimbare de configurație precum rotirea, sistemul distruge Activity-ul și îl recreează. Datele dintr-un ViewModel supraviețuiesc, starea mică de UI se păstrează cu onSaveInstanceState/rememberSaveable, iar datele persistente stau în baza de date.

Rotirea, schimbarea limbii, a temei întunecate sau a mărimii fontului sunt schimbări de configurație. Implicit, Android distruge Activity-ul curent și creează unul nou, ca să încarce resursele potrivite noii configurații (alt layout, alte texte).

Secvența e onPause, onStop, onSaveInstanceState, onDestroy, apoi pentru instanța nouă onCreate (cu savedInstanceState nenul), onStart, onRestoreInstanceState, onResume. Orice variabilă ținută doar în Activity se pierde.

Unde păstrezi datele, după tip:

  • ViewModel: supraviețuiește schimbărilor de configurație, pentru că e păstrat de ViewModelStore, nu de instanța Activity. Aici ții starea ecranului și rezultatul request-urilor, ca să nu le refaci la fiecare rotire.
  • Saved instance state (Bundle): supraviețuiește și morții procesului, dar e limitat ca mărime și trebuie să fie serializabil. Pentru ID-uri, text introdus, poziții. În ViewModel ai acces prin SavedStateHandle, în Compose prin rememberSaveable.
  • Persistență (Room, DataStore): pentru date care trebuie să rămână și după închiderea aplicației.
KOTLIN
@Composable
fun NoteEditor() {
    var text by rememberSaveable { mutableStateOf("") }   // rezistă la rotire
    TextField(value = text, onValueChange = { text = it })
}

Poți evita recrearea cu android:configChanges în manifest, dar atunci tu ești responsabil să actualizezi UI-ul pentru noua configurație. E o soluție pentru cazuri speciale (un player video, de exemplu), nu o scurtătură pentru a evita gestionarea stării.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi trei niveluri de păstrare a datelor. Greșeala tipică e să propui configChanges ca soluție generală.

30 Junior

Cum diferă ciclul de viață al unui Fragment de cel al unei Activity și ce este viewLifecycleOwner?

Răspuns scurt: Un Fragment are două cicluri de viață: al fragmentului și al view-ului său. View-ul poate fi distrus (onDestroyView) și recreat, de exemplu când fragmentul intră în back stack, în timp ce fragmentul rămâne viu. viewLifecycleOwner reprezintă ciclul de viață al view-ului.

Pe lângă callback-urile asemănătoare cu Activity (onCreate, onStart, onResume, onPause, onStop, onDestroy), Fragment-ul are callback-uri pentru view:

  • onCreateView: creezi și returnezi view-ul;
  • onViewCreated: view-ul e gata, aici legi observatorii și listener-ele;
  • onDestroyView: view-ul e distrus, dar instanța fragmentului poate continua să existe.

Când navighezi de la fragmentul A la B și A intră în back stack, A primește onDestroyView, dar nu onDestroy. Când revii, primește din nou onCreateView. De aceea există două lifecycle-uri.

Problema clasică apare când observi date folosind this (fragmentul) ca owner:

KOTLIN
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    // corect: observatorul e legat de view
    viewModel.items.observe(viewLifecycleOwner) { adapter.submitList(it) }
}

Dacă ai folosi observe(this), la fiecare revenire din back stack s-ar adăuga un observator nou, iar cel vechi ar ține referința la un view distrus: actualizări duplicate și memory leak.

La fel cu View Binding: dacă ții binding-ul într-o proprietate, setează-l pe null în onDestroyView, altfel fragmentul din back stack păstrează în memorie toată ierarhia de view-uri.

KOTLIN
private var _binding: FragmentListBinding? = null
private val binding get() = _binding!!
override fun onDestroyView() { super.onDestroyView(); _binding = null }

Cu Compose, multe din aceste probleme dispar, dar înțelegerea lor rămâne utilă în proiectele existente.

Ce urmărește intervievatorul: Se verifică dacă știi de ce viewLifecycleOwner și nu this. E una dintre cele mai frecvente surse de bug-uri în codul cu Fragment-uri.

31 Junior

Ce este un Intent și care e diferența dintre un intent explicit și unul implicit?

Răspuns scurt: Un Intent e un mesaj prin care ceri sistemului să pornească o componentă. Cel explicit numește exact clasa țintă (de obicei din aplicația ta); cel implicit descrie o acțiune (de exemplu „deschide acest link”), iar sistemul alege aplicația potrivită.

Intent-urile sunt mecanismul de comunicare dintre componente, inclusiv între aplicații diferite.

Explicit: știi componenta pe care vrei să o pornești.

KOTLIN
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("productId", 42L)
}
startActivity(intent)

Implicit: declari intenția, iar sistemul caută aplicațiile care au un intent-filter compatibil.

KOTLIN
val share = Intent(Intent.ACTION_SEND).apply {
    type = "text/plain"
    putExtra(Intent.EXTRA_TEXT, "Uite ce am găsit")
}
startActivity(Intent.createChooser(share, "Trimite prin"))

val web = Intent(Intent.ACTION_VIEW, Uri.parse("https://developer.android.com"))
startActivity(web)

Ce mai trebuie știut:

  • Datele din extras trebuie să fie de tipuri suportate de Bundle (primitive, String, Parcelable). Nu trimite obiecte mari: există o limită de câteva sute de KB pentru tranzacțiile Binder, iar depășirea ei duce la TransactionTooLargeException. Trimite un ID și încarcă datele din repository.
  • De la Android 11 (API 30), vizibilitatea pachetelor e restricționată: dacă vrei să interoghezi alte aplicații, declari în manifest un element <queries>. Pentru startActivity cu un intent implicit, poți prinde ActivityNotFoundException dacă nicio aplicație nu poate trata cererea.
  • PendingIntent e un intent pe care îl dai altei aplicații (de exemplu sistemului de notificări) ca să-l execute în numele tău; de la Android 12 trebuie să specifici FLAG_IMMUTABLE sau FLAG_MUTABLE.

Ce urmărește intervievatorul: Se verifică fundamentele de comunicare între componente. Un plus e să menționezi limita de mărime a extras-urilor.

32 Junior

Cum ceri o permisiune la rulare (runtime permission) pe Android?

Răspuns scurt: Declari permisiunea în manifest, verifici dacă e deja acordată cu ContextCompat.checkSelfPermission, iar dacă nu, o ceri prin Activity Result API (RequestPermission). Tratezi și cazul refuzului, explicând utilizatorului de ce ai nevoie de ea.

De la Android 6 (API 23), permisiunile periculoase (camera, locația, contactele, microfonul) se cer în momentul în care ai nevoie de ele, nu doar la instalare. Permisiunile normale, ca INTERNET, se acordă automat dacă sunt declarate în manifest.

Pașii:

XML
<uses-permission android:name="android.permission.CAMERA" />
KOTLIN
class ScanFragment : Fragment() {
    private val requestCamera = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        if (granted) startCamera() else showPermissionExplanation()
    }

    private fun onScanClicked() {
        when {
            ContextCompat.checkSelfPermission(requireContext(), Manifest.permission.CAMERA)
                == PackageManager.PERMISSION_GRANTED -> startCamera()
            shouldShowRequestPermissionRationale(Manifest.permission.CAMERA) ->
                showRationaleDialog { requestCamera.launch(Manifest.permission.CAMERA) }
            else -> requestCamera.launch(Manifest.permission.CAMERA)
        }
    }
}

registerForActivityResult trebuie apelat înainte ca fragmentul sau Activity-ul să ajungă în STARTED, de obicei ca proprietate inițializată la creare. Vechiul onRequestPermissionsResult e deprecated.

Bune practici: ceri permisiunea în context (când utilizatorul apasă „Scanează”), nu pe toate la pornire; explici de ce ai nevoie; aplicația trebuie să funcționeze degradat dacă e refuzată. Câteva versiuni au adus schimbări: Android 11 a introdus permisiunile acordate o singură dată, iar Android 13 (API 33) cere permisiunea POST_NOTIFICATIONS pentru notificări. După refuzuri repetate, sistemul nu mai afișează dialogul și utilizatorul trebuie trimis în setări.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi API-ul actual (Activity Result) și dacă te gândești la experiența utilizatorului când refuză.

33 Junior

Ce este process death și cum te asiguri că aplicația revine corect după el?

Răspuns scurt: Când aplicația e în fundal, sistemul îi poate omorî procesul pentru a elibera memorie. Când utilizatorul revine, Android recreează Activity-ul cu starea salvată în Bundle, dar ViewModel-ul și variabilele din memorie sunt pierdute. Te protejezi cu SavedStateHandle, rememberSaveable și date persistate.

Utilizatorul completează jumătate dintr-un formular, trece în altă aplicație să copieze un cod, iar când revine formularul e gol sau aplicația crapă. Asta e process death tratat greșit.

Ce se păstrează și ce nu:

  • se păstrează: back stack-ul de Activity-uri și Fragment-uri, starea salvată în onSaveInstanceState, SavedStateHandle, rememberSaveable și tot ce ai pus în Room sau DataStore;
  • se pierde: instanțele de ViewModel, singleton-urile, variabilele statice, cache-urile din memorie.

De aici vin bug-uri tipice: un singleton care ține „utilizatorul curent” e null după revenire, iar ecranul crapă cu NullPointerException.

KOTLIN
@HiltViewModel
class CheckoutViewModel @Inject constructor(
    private val savedState: SavedStateHandle
) : ViewModel() {
    val address: StateFlow<String> = savedState.getStateFlow("address", "")
    fun onAddressChange(value: String) { savedState["address"] = value }
}

SavedStateHandle primește și argumentele de navigare, deci după process death ecranul știe tot ce ID încărca.

Cum testezi: pornește aplicația, du-o în fundal, apoi rulează adb shell am kill com.exemplu.app (funcționează doar dacă aplicația e în fundal) și revino din lista de aplicații recente. Alternativ, din Developer Options activezi „Don't keep activities”, deși acesta simulează doar distrugerea Activity-ului, nu a procesului.

Regula de design: în Bundle pui doar starea mică introdusă de utilizator și ID-uri. Datele mari se reîncarcă din repository pe baza acelor ID-uri.

Ce urmărește intervievatorul: Se verifică dacă ai întâlnit problema în practică. Mulți candidați cred că ViewModel-ul supraviețuiește și morții procesului.

34 Mid

Cum funcționează back stack-ul și ce sunt launch modes (singleTop, singleTask)?

Răspuns scurt: Back stack-ul e stiva de ecrane dintr-un task, iar back scoate ecranul din vârf. singleTop refolosește instanța aflată deja în vârf, iar singleTask păstrează o singură instanță în task și elimină ce e deasupra ei.

Un task e colecția de Activity-uri cu care utilizatorul interacționează pentru un scop, organizate ca stivă. Implicit (standard), fiecare startActivity creează o instanță nouă deasupra.

Launch modes principale, declarate în manifest sau obținute prin flag-uri:

  • standard: instanță nouă de fiecare dată;
  • singleTop: dacă Activity-ul e deja în vârful stivei, nu se creează altul; instanța existentă primește onNewIntent(). Util pentru o notificare care deschide ecranul pe care ești deja;
  • singleTask: o singură instanță în task; dacă există, tot ce e deasupra se elimină și ea primește onNewIntent(). Folosit des pentru Activity-ul principal în aplicații cu deep link-uri;
  • singleInstance și singleInstancePerTask (API 31+): cazuri rare.

Flag-uri echivalente frecvente: FLAG_ACTIVITY_CLEAR_TOP, FLAG_ACTIVITY_NEW_TASK, FLAG_ACTIVITY_CLEAR_TASK. După logout, de exemplu:

KOTLIN
startActivity(Intent(this, LoginActivity::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
})

În aplicațiile moderne cu o singură Activity, back stack-ul relevant e cel al bibliotecii Navigation (pentru Fragment-uri sau Compose). Acolo folosești popUpTo și launchSingleTop în opțiunile de navigare, de exemplu ca să nu poți reveni cu back la ecranul de login după autentificare. Back-ul predictiv introdus în Android 13 și 14 cere ca tratarea lui back să se facă prin OnBackPressedDispatcher sau BackHandler, nu prin onBackPressed(), care e deprecated.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să rezolvi scenarii reale (logout, notificări, deep link-uri) fără ecrane duplicate în stivă.

35 Mid

Când folosești WorkManager, când un foreground service și când o corutină simplă?

Răspuns scurt: Corutina în viewModelScope e pentru lucru legat de ecran. WorkManager e pentru lucru amânabil, garantat și după închiderea aplicației. Foreground service e pentru lucru imediat, vizibil utilizatorului, cu notificare permanentă.

Alegerea depinde de două întrebări: trebuie să continue după ce utilizatorul pleacă din ecran sau din aplicație? Trebuie să ruleze imediat sau poate fi amânat?

  • Corutină în viewModelScope: încărcarea datelor pentru ecran, o căutare. Dacă utilizatorul închide ecranul, lucrul se anulează, ceea ce e corect.
  • WorkManager: sincronizarea datelor, încărcarea unei poze în fundal, curățarea cache-ului. Supraviețuiește închiderii aplicației și repornirii telefonului, respectă constrângeri (doar pe Wi-Fi, doar la încărcare), are reîncercări cu backoff și se poate înlănțui.
KOTLIN
val request = OneTimeWorkRequestBuilder<UploadWorker>()
    .setConstraints(Constraints(requiredNetworkType = NetworkType.CONNECTED))
    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
    .build()
WorkManager.getInstance(context)
    .enqueueUniqueWork("upload-$photoId", ExistingWorkPolicy.KEEP, request)
  • Foreground service: redarea muzicii, navigația GPS, un apel. Are notificare permanentă. De la Android 14 (API 34) trebuie să declari un foregroundServiceType (de exemplu mediaPlayback, location) și permisiunea corespunzătoare, iar Google Play verifică dacă tipul declarat se potrivește cu folosirea reală.

Există și scope-uri la nivel de aplicație, injectate, pentru lucru scurt care trebuie să termine chiar dacă ecranul se închide (de exemplu salvarea unei schimbări). Pentru alarme la oră exactă există AlarmManager, dar și el are restricții. Greșeala frecventă e un Service simplu de fundal pentru sincronizare: pe versiunile noi, sistemul îl oprește în scurt timp după ce aplicația iese din prim-plan.

Ce urmărește intervievatorul: Se verifică dacă știi restricțiile de fundal din versiunile noi de Android și dacă alegi unealta potrivită, nu „un serviciu” pentru tot.

36 Mid

Ce diferență e între Application Context și Activity Context și cum duce folosirea greșită la memory leak?

Răspuns scurt: Application Context trăiește cât procesul; Activity Context e legat de un ecran și conține tema. Dacă un obiect de lungă durată ține un Activity Context, Activity-ul nu mai poate fi eliberat după distrugere: memory leak.

Context dă acces la resurse, servicii de sistem, fișiere și preferințe. Există mai multe tipuri, cu durate de viață diferite.

Activity Context:

  • conține tema Activity-ului, deci e necesar pentru a crea view-uri, dialoguri și pentru a porni Activity-uri fără FLAG_ACTIVITY_NEW_TASK;
  • dispare la rotire sau la închiderea ecranului.

Application Context (context.applicationContext):

  • unul singur pe proces;
  • potrivit pentru baze de date, clienți HTTP, WorkManager, analytics.

Leak-ul clasic:

KOTLIN
object ImageCache {
    lateinit var context: Context          // dacă primește o Activity, leak
    fun init(ctx: Context) { context = ctx.applicationContext }  // corect
}

Activity-ul rotit ar trebui colectat de garbage collector, dar singleton-ul îl ține în viață împreună cu toată ierarhia de view-uri și bitmap-urile. După câteva rotiri, memoria crește până la OutOfMemoryError.

Alte surse frecvente de leak-uri:

  • un ViewModel care ține referințe la Activity, Fragment sau View (ViewModel-ul trăiește mai mult decât ele); dacă ai nevoie de context, folosește AndroidViewModel sau injectează @ApplicationContext cu Hilt;
  • listener-e înregistrate și nedezînregistrate;
  • clase interne non-statice și lambde care capturează Activity-ul și sunt date unui thread de lungă durată.

Regula: obiectele care trăiesc mai mult decât ecranul primesc doar Application Context. Pentru UI (dialoguri, inflate), folosești contextul Activity-ului, care are tema corectă. Biblioteca LeakCanary detectează automat aceste probleme în build-urile de debug.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi duratele de viață diferite. Un candidat care spune „folosesc mereu applicationContext” va primi întrebarea despre dialoguri și teme.

37 Senior

Cum ai investiga un memory leak sau o creștere de memorie raportată într-o aplicație Android?

Răspuns scurt: Reproduc scenariul, rulez LeakCanary în build-ul de debug ca să găsesc obiectele reținute și lanțul de referințe, apoi confirm cu Memory Profiler din Android Studio printr-un heap dump. Repar referința care ține obiectul în viață și verific că memoria revine după garbage collection.

Procesul pe care îl urmez:

  • Reproducere: identific fluxul suspect (de exemplu deschid și închid de zece ori ecranul de detalii, rotesc telefonul). Fără un scenariu reproductibil, investigația e ghicit.
  • LeakCanary: adăugat ca debugImplementation, urmărește automat Activity-uri, Fragment-uri, view-uri și ViewModel-uri distruse. Dacă un obiect nu e colectat după câteva secunde, face un heap dump și afișează leak trace: lanțul de referințe de la o rădăcină GC (un thread, un câmp static) până la obiectul reținut. De obicei, vinovatul e evident în acel lanț: un singleton, un listener, un callback.
  • Memory Profiler din Android Studio: urmăresc graficul de memorie în timpul scenariului, forțez garbage collection și fac heap dump. Filtrez după pachetul aplicației și caut instanțe multiple ale aceleiași Activity sau bitmap-uri mari. Pot înregistra și alocările, ca să găsesc cod care creează multe obiecte într-o buclă (de exemplu în onDraw sau într-un composable care se recompune des).
  • Remedierea: tai referința greșită (applicationContext în loc de Activity, dezînregistrarea listener-ului în callback-ul simetric, _binding = null în onDestroyView, awaitClose în callbackFlow).
  • Verificare: refac scenariul și confirm că numărul de instanțe revine la normal.

Nu orice creștere de memorie e un leak: un cache de imagini (Coil, Glide) ocupă memorie intenționat, în limitele configurate. Diferența e că un cache se golește sub presiune, iar un leak nu. În producție, OutOfMemoryError apare în Android Vitals și în Crashlytics, dar stack trace-ul arată doar unde s-a terminat memoria, nu cauza; de aceea reproducerea locală e esențială.

Ce urmărește intervievatorul: La senior se verifică metoda de lucru, nu doar cunoașterea uneltelor. Un plus e distincția dintre cache și leak.

38 Senior

Ce este un ANR și ce rol au Looper și Handler pe thread-ul principal?

Răspuns scurt: ANR (Application Not Responding) apare când thread-ul principal e blocat prea mult, de exemplu 5 secunde fără răspuns la input. Thread-ul principal rulează un Looper care execută mesaje dintr-o coadă, iar Handler pune mesaje în ea.

Thread-ul principal (main sau UI thread) rulează o buclă infinită: Looper ia mesaje din MessageQueue și le execută unul câte unul. Desenarea cadrelor, evenimentele de touch, callback-urile de lifecycle, toate sunt mesaje în aceeași coadă. Dacă un mesaj durează 2 secunde, în acele 2 secunde nu se desenează nimic și nu se procesează niciun touch.

Handler e legat de un Looper și pune mesaje sau Runnable în coada lui, eventual cu întârziere. Dispatchers.Main din coroutines e implementat peste un Handler pe main looper.

Sistemul declanșează ANR, printre altele, când:

  • un eveniment de input nu primește răspuns în 5 secunde;
  • un BroadcastReceiver nu termină onReceive în timpul permis;
  • un serviciu pornit în prim-plan nu apelează startForeground la timp.

Cauze reale frecvente:

  • I/O pe main: citiri din SharedPreferences cu commit(), interogări de bază de date, fișiere;
  • runBlocking pe main, care așteaptă o corutină;
  • lock contention: main așteaptă un lock ținut de un thread de fundal;
  • inițializări grele în Application.onCreate.

Cum depanezi: Android Vitals din Play Console și Crashlytics arată stack trace-ul thread-ului principal la momentul ANR-ului. Local, StrictMode în debug detectează accesul la disc și rețea pe main:

KOTLIN
if (BuildConfig.DEBUG) {
    StrictMode.setThreadPolicy(
        StrictMode.ThreadPolicy.Builder().detectDiskReads().detectDiskWrites()
            .detectNetwork().penaltyLog().build()
    )
}

Rata de ANR-uri afectează și vizibilitatea aplicației în Google Play, deci e o metrică urmărită.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de thread al Android. Răspunsul bun leagă ANR-ul de coada de mesaje, nu doar de „cod lent”.

Jetpack Compose și UI

39 Junior

Ce este Jetpack Compose și prin ce diferă de sistemul clasic de View-uri cu XML?

Răspuns scurt: Compose este toolkit-ul declarativ modern de UI pentru Android: descrii în funcții Kotlin cum arată interfața pentru o anumită stare, iar framework-ul o actualizează când starea se schimbă. În sistemul cu View-uri, construiești ierarhia în XML și o modifici manual, imperativ.

În modelul imperativ, ai un layout XML, obții referințe la view-uri și le modifici: textView.text = ..., progressBar.visibility = View.GONE. Pe măsură ce ecranul crește, devine greu să ții sincronizate toate view-urile cu starea reală. Apar bug-uri de genul „spinner-ul a rămas vizibil după eroare”.

În Compose, UI-ul e o funcție de stare: UI = f(state).

KOTLIN
@Composable
fun ProductScreen(state: UiState, onRetry: () -> Unit) {
    when (state) {
        UiState.Loading -> CircularProgressIndicator()
        is UiState.Success -> ProductList(state.items)
        is UiState.Error -> ErrorMessage(state.message, onRetry)
    }
}

Nu ascunzi și nu afișezi nimic manual. Când starea se schimbă, Compose rulează din nou funcțiile afectate (recompunere) și actualizează doar ce s-a schimbat.

Diferențe practice:

  • totul e Kotlin, fără XML, fără findViewById, fără adaptoare pentru liste (LazyColumn le înlocuiește);
  • componentele se refolosesc ca funcții cu parametri, nu prin moștenire de clase;
  • previzualizare în Android Studio cu @Preview;
  • animațiile și temele sunt mai simple de scris.

Compose e recomandarea Google pentru aplicații noi, dar multe proiecte existente au încă View-uri, iar cele două sisteme pot conviețui (ComposeView și AndroidView). La interviu e util să le cunoști pe amândouă la nivel de bază.

Ce urmărește intervievatorul: Se verifică dacă înțelegi modelul declarativ, nu doar sintaxa. Formula „UI e o funcție de stare” e exact ce vrea să audă intervievatorul.

40 Junior

Ce este o funcție @Composable și ce înseamnă recompunerea?

Răspuns scurt: O funcție @Composable descrie o parte din UI și poate apela alte composable-uri. Recompunerea înseamnă că Compose rulează din nou composable-urile care citesc o stare care s-a schimbat, ca să actualizeze UI-ul.

Adnotarea @Composable îi spune pluginului de compilare Compose să transforme funcția: primește un parametru ascuns (Composer) și poate fi apelată doar din alte composable-uri. Funcția nu returnează un view, ci emite UI în arborele de compoziție.

KOTLIN
@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    Button(onClick = { count++ }) {
        Text("Apăsat de $count ori")
    }
}

Când apeși butonul, count se schimbă. Compose știe că Text din interiorul Button citește count, așa că programează recompunerea doar pentru zona care citește această stare.

Reguli importante, care decurg din felul în care funcționează recompunerea:

  • composable-urile pot rula de multe ori, chiar la fiecare cadru în timpul unei animații, deci trebuie să fie rapide;
  • pot rula în orice ordine și pot fi sărite dacă parametrii nu s-au schimbat;
  • nu trebuie să aibă efecte secundare direct în corp: nu face request-uri, nu scrie în baza de date, nu modifica variabile globale. Pentru asta există API-urile de side effects (LaunchedEffect și altele);
  • recompunerea poate fi anulată și reluată dacă starea se schimbă din nou.

O greșeală tipică de începător e o variabilă simplă (var count = 0) în composable: la recompunere se reinițializează, iar schimbarea ei nici nu declanșează recompunere, pentru că nu e o stare observabilă Compose.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi că un composable poate rula oricând și de multe ori, deci nu pui efecte secundare în corpul lui.

41 Junior

Care e diferența dintre remember și rememberSaveable?

Răspuns scurt: remember păstrează o valoare între recompuneri, cât timp composable-ul rămâne în compoziție. rememberSaveable o păstrează și peste recrearea Activity-ului (rotire) și process death, salvând-o în mecanismul de saved instance state.

Fără remember, orice obiect creat în corpul unui composable s-ar crea din nou la fiecare recompunere. remember { } calculează valoarea o dată, la prima compoziție, și o returnează la următoarele.

KOTLIN
@Composable
fun SearchBox() {
    var query by rememberSaveable { mutableStateOf("") }   // rezistă la rotire
    var expanded by remember { mutableStateOf(false) }     // se resetează la rotire
    val formatter = remember { DecimalFormat("#,##0.00") } // obiect scump, creat o dată
    // ...
}

Diferențele:

  • remember se pierde când composable-ul iese din compoziție (de exemplu navighezi la alt ecran și ecranul curent e eliminat) și la recrearea Activity-ului.
  • rememberSaveable salvează valoarea în Bundle. Supraviețuiește rotirii, process death-ului și, în Navigation Compose, revenirii la un ecran din back stack. Funcționează direct cu tipurile suportate de Bundle; pentru clase proprii îți trebuie @Parcelize sau un Saver custom.

remember acceptă și chei: remember(userId) { computeSomething(userId) } recalculează când se schimbă userId.

Cum alegi: starea introdusă de utilizator pe care nu vrei să o piardă (text în câmpuri, tab-ul selectat) merge în rememberSaveable. Starea pur vizuală și efemeră (un meniu deschis, o animație) merge în remember. Iar starea care ține de logica ecranului și de date stă în ViewModel, nu în composable. Nu pune liste mari în rememberSaveable, pentru că Bundle are limite de dimensiune.

Ce urmărește intervievatorul: Se verifică dacă știi ce se pierde la rotire. Follow-up-ul obișnuit: unde ar trebui să stea de fapt starea, în composable sau în ViewModel.

42 Junior

Ce înseamnă state hoisting în Compose și de ce e important?

Răspuns scurt: State hoisting înseamnă să muți starea din composable-ul care o folosește în apelantul lui, transmițând valoarea ca parametru și schimbările ca un callback. Astfel componenta devine stateless, reutilizabilă, ușor de testat și de previzualizat.

Un composable cu stare internă e comod, dar greu de controlat din exterior. Dacă vrei ca alt element să reacționeze la textul introdus, sau să resetezi câmpul după trimitere, nu ai acces la stare.

Pattern-ul: componenta primește value: T și onValueChange: (T) -> Unit. Starea urcă (hoisting) până la cel mai apropiat strămoș comun al tuturor celor care o citesc sau o modifică.

KOTLIN
@Composable
fun QuantityPicker(quantity: Int, onQuantityChange: (Int) -> Unit) {
    Row(verticalAlignment = Alignment.CenterVertically) {
        IconButton(onClick = { onQuantityChange(quantity - 1) }, enabled = quantity > 1) {
            Icon(Icons.Default.Remove, contentDescription = "Scade")
        }
        Text("$quantity")
        IconButton(onClick = { onQuantityChange(quantity + 1) }) {
            Icon(Icons.Default.Add, contentDescription = "Crește")
        }
    }
}

@Composable
fun CartItem(viewModel: CartViewModel) {
    val qty by viewModel.quantity.collectAsStateWithLifecycle()
    QuantityPicker(quantity = qty, onQuantityChange = viewModel::setQuantity)
}

Beneficiile:

  • o singură sursă de adevăr: valoarea există într-un singur loc;
  • reutilizare: QuantityPicker funcționează oriunde, cu orice sursă de stare;
  • testare și @Preview: îi dai orice valoare fixă, fără ViewModel;
  • flux unidirecțional: starea coboară, evenimentele urcă.

Așa sunt construite și componentele Material: TextField(value, onValueChange). Nu urca starea mai sus decât e nevoie: dacă doar componenta folosește o stare pur vizuală, o poate ține intern. Pentru ecran, de obicei starea urcă până în ViewModel, iar composable-ul de ecran devine stateless.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii componente stateless și dacă înțelegi fluxul unidirecțional al datelor.

43 Junior

Ce este un Modifier și de ce contează ordinea în care înlănțuiești modificatorii?

Răspuns scurt: Modifier e un lanț ordonat de instrucțiuni care decorează sau configurează un composable: dimensiune, padding, fundal, click, aliniere. Fiecare modificator se aplică peste rezultatul celor dinaintea lui, deci padding înainte de background dă alt rezultat decât invers.

Aproape fiecare composable acceptă un parametru modifier. Prin el controlezi aspectul și comportamentul fără să modifici componenta.

KOTLIN
@Composable
fun Tag(text: String, onClick: () -> Unit, modifier: Modifier = Modifier) {
    Text(
        text = text,
        modifier = modifier
            .clip(RoundedCornerShape(8.dp))
            .background(MaterialTheme.colorScheme.primaryContainer)
            .clickable(onClick = onClick)
            .padding(horizontal = 12.dp, vertical = 6.dp)
    )
}

Ordinea se citește de sus în jos, din exterior spre interior. În exemplu, colțurile sunt rotunjite, fundalul acoperă toată pastila, zona de click include padding-ul, iar padding-ul se aplică în interior, în jurul textului.

Dacă ai scrie .padding(12.dp).background(...), padding-ul ar fi în afara fundalului, ca o margine transparentă. Dacă ai pune .clickable după .padding, zona de atingere ar fi mai mică decât pastila vizibilă, iar efectul de ripple ar fi tăiat. La fel, clip trebuie să fie înaintea lui background și clickable, ca să le taie forma.

Convenții bune:

  • componentele tale acceptă modifier: Modifier = Modifier ca prim parametru opțional și îl aplică pe elementul rădăcină;
  • apelantul decide poziționarea și dimensiunea (fillMaxWidth, weight), componenta decide aspectul intern;
  • nu crea modificatori complicați în bucle fără motiv; sunt ieftini, dar lanțurile lungi se citesc greu.

Compose nu are margin separat: „margin” e un padding aplicat înainte de fundal.

Ce urmărește intervievatorul: Se verifică înțelegerea ordinii modificatorilor, o sursă frecventă de bug-uri vizuale. Exemplul cu zona de click e un bun răspuns-model.

44 Junior

Cum afișezi o listă lungă în Compose și de ce e important parametrul key din LazyColumn?

Răspuns scurt: Folosești LazyColumn (sau LazyRow, LazyVerticalGrid), care compune doar elementele vizibile pe ecran. key dă fiecărui element o identitate stabilă, astfel încât la inserări, ștergeri sau reordonări Compose să păstreze starea și animațiile elementului corect.

Un Column cu verticalScroll compune toate elementele, chiar și cele care nu se văd. Pentru zece elemente e în regulă; pentru o mie, e lent și consumă memorie. LazyColumn e echivalentul lui RecyclerView: compune și măsoară doar ce intră pe ecran, plus puțin în jur.

KOTLIN
@Composable
fun MessageList(messages: List<Message>, onClick: (Long) -> Unit) {
    LazyColumn(contentPadding = PaddingValues(16.dp)) {
        item { Header() }
        items(items = messages, key = { it.id }) { message ->
            MessageRow(
                message = message,
                onClick = { onClick(message.id) },
                modifier = Modifier.animateItem()
            )
        }
    }
}

Fără key, identitatea unui element e poziția lui. Dacă inserezi un mesaj nou în vârful listei, fiecare poziție primește alt mesaj, iar starea internă (remember) a rândurilor rămâne la poziția veche: un rând expandat apare ca expandat pentru alt mesaj. Cu key = { it.id }, starea și poziția de scroll urmăresc elementul, nu indexul. Modifier.animateItem() (disponibil din Compose Foundation 1.7) se bazează și el pe chei.

Reguli:

  • cheile trebuie să fie unice și stabile, iar pe Android trebuie să poată fi salvate în Bundle (Long, String, Int sunt sigure);
  • folosește contentType dacă ai tipuri diferite de rânduri, ca să fie refolosite corect;
  • nu pune un LazyColumn în interiorul unui Column cu scroll pe aceeași direcție, pentru că primește înălțime infinită și aruncă excepție.

Pentru liste foarte mari sau paginate din rețea, combini cu Paging 3 (collectAsLazyPagingItems).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi echivalentul RecyclerView și de ce key contează pentru stare, nu doar pentru performanță.

45 Mid

Ce sunt side effects în Compose? Explică LaunchedEffect, DisposableEffect și rememberCoroutineScope.

Răspuns scurt: Side effects sunt operații care ies din lumea compoziției (corutine, listener-e, analytics). LaunchedEffect pornește o corutină legată de chei, DisposableEffect înregistrează ceva și oferă onDispose pentru curățenie, iar rememberCoroutineScope dă un scope pentru corutine pornite din callback-uri precum onClick.

Pentru că un composable poate rula de multe ori, codul cu efecte trebuie pus în API-uri care controlează când rulează.

LaunchedEffect(key): pornește o corutină când composable-ul intră în compoziție și o anulează și o repornește când se schimbă cheia. La ieșirea din compoziție, corutina e anulată.

KOTLIN
LaunchedEffect(Unit) {
    viewModel.events.collect { event ->
        when (event) {
            is Event.ShowSnackbar -> snackbarHostState.showSnackbar(event.text)
        }
    }
}

DisposableEffect(key): pentru resurse care trebuie eliberate.

KOTLIN
val lifecycleOwner = LocalLifecycleOwner.current
DisposableEffect(lifecycleOwner) {
    val observer = LifecycleEventObserver { _, e -> if (e == Lifecycle.Event.ON_RESUME) refresh() }
    lifecycleOwner.lifecycle.addObserver(observer)
    onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
}

rememberCoroutineScope(): un scope legat de compoziție, pentru acțiuni declanșate de utilizator, unde LaunchedEffect nu se poate folosi (nu e composable în onClick).

KOTLIN
val scope = rememberCoroutineScope()
Button(onClick = { scope.launch { listState.animateScrollToItem(0) } }) { Text("Sus") }

Mai sunt SideEffect (rulează după fiecare recompunere reușită), rememberUpdatedState (pentru a folosi ultima valoare a unui callback într-un efect de lungă durată, fără a-l reporni) și produceState.

Greșeli tipice: LaunchedEffect(true) sau Unit folosit când de fapt efectul depinde de un parametru, deci nu se mai repornește; și request-uri lansate direct din corpul composable-ului.

Ce urmărește intervievatorul: Se verifică dacă alegi efectul potrivit și dacă înțelegi rolul cheilor. Răspunsul slab descrie doar LaunchedEffect(Unit).

46 Mid

Cum eviți recompunerile inutile în Compose? Ce rol are derivedStateOf?

Răspuns scurt: Citești starea cât mai târziu și cât mai local, transmiți tipuri stabile, folosești chei în liste și calculele scumpe le pui în remember. derivedStateOf creează o stare derivată care declanșează recompunere doar când rezultatul se schimbă efectiv, nu la fiecare schimbare a stării sursă.

Compose sare peste un composable dacă parametrii lui nu s-au schimbat și sunt considerați stabili. Recompunerile inutile apar când un ecran întreg citește o stare care se schimbă des, cum ar fi poziția de scroll.

Exemplu clasic: afișezi un buton „Sus” doar când lista a trecut de primul element.

KOTLIN
val listState = rememberLazyListState()
val showButton by remember {
    derivedStateOf { listState.firstVisibleItemIndex > 0 }
}
AnimatedVisibility(visible = showButton) { ScrollToTopButton() }

Fără derivedStateOf, citirea directă a lui listState.firstVisibleItemIndex ar declanșa recompunere la fiecare schimbare de index, deși rezultatul boolean rămâne același. derivedStateOf e util doar când sursa se schimbă mai des decât rezultatul; pentru un simplu fullName = first + last nu aduce nimic.

Alte tehnici:

  • amânarea citirii: transmite un lambda în loc de valoare (offset = { scrollState.value }) și folosește variantele de modificatori cu lambda (Modifier.offset { IntOffset(0, offset()) }, graphicsLayer { }). Starea e citită în faza de layout sau de desenare, iar compoziția nu mai rulează deloc.
  • stabilitate: clase cu val și tipuri stabile; List din Kotlin e considerată instabilă de compilator, dar cu Strong Skipping (activ implicit de la Kotlin 2.0.20) instanțele neschimbate se compară după referință, iar problema se reduce mult.
  • lambde stabile: referințe de funcții (viewModel::onClick) sau lambde memorate.

Cum măsori: Layout Inspector din Android Studio arată numărul de recompuneri și de skip-uri pe fiecare composable. Optimizează doar unde vezi probleme reale.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi când derivedStateOf ajută și când nu, și dacă măsori înainte de a optimiza.

47 Mid

Cum implementezi navigarea între ecrane într-o aplicație Compose și cum transmiți argumente?

Răspuns scurt: Folosești Navigation Compose: un NavHost cu un NavController și câte o destinație composable pentru fiecare ecran. Argumentele se transmit prin rută; din Navigation 2.8 rutele pot fi clase @Serializable type-safe. Ecranul de destinație citește argumentele din SavedStateHandle în ViewModel.

Biblioteca androidx.navigation:navigation-compose gestionează back stack-ul, animațiile de tranziție și restaurarea stării.

Cu API-ul type-safe (Navigation 2.8+, cu pluginul kotlinx.serialization):

KOTLIN
@Serializable object ProductList
@Serializable data class ProductDetail(val id: Long)

@Composable
fun AppNavHost(navController: NavHostController = rememberNavController()) {
    NavHost(navController, startDestination = ProductList) {
        composable<ProductList> {
            ProductListScreen(onOpen = { id -> navController.navigate(ProductDetail(id)) })
        }
        composable<ProductDetail> {
            ProductDetailScreen(onBack = { navController.popBackStack() })
        }
    }
}

@HiltViewModel
class ProductDetailViewModel @Inject constructor(
    savedStateHandle: SavedStateHandle, repo: ProductRepository
) : ViewModel() {
    private val args = savedStateHandle.toRoute<ProductDetail>()
    val product = repo.observe(args.id)
}

Înainte de 2.8, rutele erau șiruri de caractere ("detail/{id}") cu argumente declarate prin navArgument, mai predispuse la greșeli de scriere.

Bune practici:

  • composable-urile de ecran nu primesc NavController, ci callback-uri (onOpen, onBack). Le poți testa și previzualiza separat.
  • transmiți ID-uri, nu obiecte întregi; ecranul încarcă datele din repository.
  • popUpTo și launchSingleTop pentru fluxuri de tip login sau bottom navigation.

Google lucrează și la Navigation 3, o bibliotecă nouă în care back stack-ul e o listă de stare pe care o controlezi direct. Merită să știi că există, dar majoritatea proiectelor folosesc încă Navigation 2.x.

Ce urmărește intervievatorul: Se verifică experiența practică cu navigarea și separarea responsabilităților. Transmiterea obiectelor mari ca argumente e o greșeală frecventă.

48 Mid

Cum implementezi o temă cu Material 3 în Compose, inclusiv modul întunecat?

Răspuns scurt: Definești două ColorScheme (light și dark), tipografia și formele, apoi le dai lui MaterialTheme într-un composable propriu, de obicei AppTheme. Alegi schema după isSystemInDarkTheme() și, pe Android 12+, poți folosi culori dinamice din wallpaper.

Material 3 (Material You) organizează culorile pe roluri: primary, onPrimary, primaryContainer, surface, onSurface, error și altele. Componentele Material le folosesc automat, deci schimbi tema într-un singur loc.

KOTLIN
private val LightColors = lightColorScheme(
    primary = Color(0xFF1B5E9A),
    secondary = Color(0xFF4F6D7A)
)
private val DarkColors = darkColorScheme(
    primary = Color(0xFF9DCAFF),
    secondary = Color(0xFFB4CAD6)
)

@Composable
fun AppTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    dynamicColor: Boolean = true,
    content: @Composable () -> Unit
) {
    val context = LocalContext.current
    val colors = when {
        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S ->
            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
        darkTheme -> DarkColors
        else -> LightColors
    }
    MaterialTheme(colorScheme = colors, typography = AppTypography, content = content)
}

În componente, folosești rolurile, nu culori fixe: MaterialTheme.colorScheme.surface, MaterialTheme.typography.titleMedium. Dacă scrii Color.White direct, textul dispare în modul întunecat.

Câteva detalii utile:

  • perechile primary/onPrimary garantează contrastul textului pe fundal;
  • Surface setează automat culoarea conținutului potrivită;
  • pentru culori proprii care nu există în Material (de exemplu „success”), poți crea o clasă de culori expusă printr-un CompositionLocal;
  • tema XML din themes.xml contează în continuare pentru fereastra de pornire și bara de sistem;
  • verifică ecranele cu @Preview(uiMode = UI_MODE_NIGHT_YES) și cu mărimi de font mari.

Ce urmărește intervievatorul: Intervievatorul verifică dacă folosești roluri de culoare și nu valori fixe, cauza tipică a bug-urilor în modul întunecat.

49 Senior

Ce înseamnă stabilitatea în Compose și ce s-a schimbat odată cu Strong Skipping Mode?

Răspuns scurt: Compilatorul Compose marchează tipurile ca stabile dacă poate garanta că schimbările lor sunt observabile. Inițial, un composable cu parametru instabil (de exemplu List) nu putea fi sărit la recompunere. Strong Skipping, implicit de la Kotlin 2.0.20, permite sărirea și pentru parametri instabili, comparându-i după referință.

La recompunere, Compose decide pentru fiecare composable dacă îl poate sări (skip). Un tip e stabil dacă e imuabil (primitive, String, clase cu doar val de tipuri stabile) sau dacă își notifică schimbările prin State. Tipurile din alte module care nu folosesc compilatorul Compose și interfețele precum List sunt considerate instabile, pentru că implementarea ar putea fi mutabilă.

Înainte de Strong Skipping, un composable cu un parametru instabil se recompunea mereu, chiar dacă primea exact aceeași listă. Soluțiile erau adnotările @Immutable/@Stable, colecțiile din kotlinx.collections.immutable (ImmutableList) sau un fișier de configurare a stabilității.

Cu Strong Skipping (activ implicit în compilatorul Compose începând cu Kotlin 2.0.20):

  • composable-urile cu parametri instabili pot fi sărite; parametrii instabili se compară cu ===, cei stabili cu equals();
  • lambdele sunt memorate automat, inclusiv cele care capturează valori instabile.
KOTLIN
@Composable
fun Tags(tags: List<String>) { /* ... */ }
// sărit dacă primește aceeași instanță de listă

Consecința practică: dacă ViewModel-ul produce mereu o listă nouă (de exemplu items.map { } la fiecare emisie, chiar cu același conținut), comparația după referință eșuează și se recompune. Rezolvarea e la sursă: distinctUntilChanged() pe flow sau date imuabile reutilizate.

Pentru diagnostic, rapoartele compilatorului Compose (reportsDestination în configurarea Gradle) arată ce clase sunt stabile și ce composable-uri pot fi sărite. Contează mai mult pentru ecranele cu animații și liste mari; pentru majoritatea ecranelor, Strong Skipping a făcut problema marginală.

Ce urmărește intervievatorul: La senior se verifică înțelegerea mecanismului intern și a versiunilor. Un candidat care recomandă @Stable peste tot fără măsurători ridică semne de întrebare.

50 Senior

Cum ai migra treptat o aplicație mare bazată pe View-uri și Fragment-uri la Jetpack Compose?

Răspuns scurt: Incremental, ecran cu ecran: ecranele noi le scrii în Compose, iar în cele vechi introduci Compose prin ComposeView. Unde ai nevoie de view-uri existente în Compose folosești AndroidView. Începi cu tema comună și componentele de bază și măsori performanța pe parcurs.

O rescriere completă blochează livrarea de funcționalități și adună riscuri. Interoperabilitatea dintre Compose și View-uri permite o migrare treptată, iar strategia pe care aș propune-o are câțiva pași.

1. Fundația: adaug dependențele și creez tema Compose care reproduce culorile și tipografia din tema XML, ca ecranele să arate la fel. Construiesc un set mic de componente de bază (butoane, câmpuri, carduri), care devin design system-ul intern.

2. Ecrane noi în Compose: orice funcționalitate nouă se scrie direct în Compose, găzduită într-un Fragment existent:

KOTLIN
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, s: Bundle?) =
    ComposeView(requireContext()).apply {
        setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
        setContent { AppTheme { SettingsScreen(viewModel) } }
    }

Strategia de compoziție contează în Fragment-uri, ca compoziția să fie eliberată odată cu view-ul, nu cu fragmentul.

3. Ecrane existente, de jos în sus: înlocuiesc elemente izolate (un rând din listă, un card) și apoi ecrane întregi, începând cu cele simple și des modificate. Pentru componente greu de rescris (o hartă, un player), folosesc AndroidView în Compose.

4. Logica rămâne: ViewModel-urile și repository-urile nu se schimbă; doar stratul de UI se modifică. Dacă ViewModel-ul expune deja StateFlow, migrarea UI-ului e mult mai ușoară.

5. Navigarea: o păstrez în Fragment-uri până când majoritatea ecranelor sunt în Compose; abia apoi trec la Navigation Compose.

Pe parcurs urmăresc dimensiunea APK-ului, timpul de pornire (cu baseline profiles) și testele UI. Echipa are nevoie de timp de învățare și de reguli comune în code review, altfel fiecare scrie Compose diferit.

Ce urmărește intervievatorul: Se verifică gândirea de ansamblu și gestionarea riscului. Răspunsul slab propune rescrierea completă a aplicației.

Arhitectură: MVVM, ViewModel și Hilt

51 Junior

Ce este arhitectura MVVM și cum se aplică într-o aplicație Android?

Răspuns scurt: MVVM (Model-View-ViewModel) separă UI-ul (View) de logica de prezentare (ViewModel) și de date (Model, de obicei repository-uri). View-ul observă starea expusă de ViewModel și îi trimite evenimente, iar ViewModel-ul nu știe nimic despre View.

Fără o arhitectură, logica ajunge în Activity: request-uri, validări, formatare, toate amestecate cu codul de UI. Rezultatul e greu de testat și se strică la rotire.

În MVVM pe Android:

  • View: Activity, Fragment sau composable-uri. Afișează starea și transmite acțiunile utilizatorului. Nu conține logică de business.
  • ViewModel: ține starea ecranului (de obicei un StateFlow<UiState>), apelează repository-urile și transformă datele în ceva gata de afișat. Nu are referințe la View, Activity sau Context de UI.
  • Model: stratul de date. Repository-uri care decid dacă datele vin din rețea, din Room sau din cache.
KOTLIN
data class LoginUiState(val email: String = "", val isLoading: Boolean = false, val error: String? = null)

@HiltViewModel
class LoginViewModel @Inject constructor(private val auth: AuthRepository) : ViewModel() {
    private val _state = MutableStateFlow(LoginUiState())
    val state: StateFlow<LoginUiState> = _state.asStateFlow()

    fun onEmailChange(value: String) = _state.update { it.copy(email = value, error = null) }

    fun onSubmit() = viewModelScope.launch {
        _state.update { it.copy(isLoading = true) }
        val result = auth.login(_state.value.email)
        _state.update { it.copy(isLoading = false, error = result.exceptionOrNull()?.message) }
    }
}

Avantajele: ViewModel-ul se testează cu teste unitare simple, pe JVM, fără emulator; starea supraviețuiește rotirii; UI-ul poate fi schimbat (de exemplu de la View-uri la Compose) fără să atingi logica.

Varianta recomandată de Google în ghidul de arhitectură este practic MVVM cu flux unidirecțional al datelor: starea curge din ViewModel spre UI, iar evenimentele merg invers.

Ce urmărește intervievatorul: Se verifică dacă știi responsabilitatea fiecărui strat. Semnalul de alarmă e un ViewModel care ține referințe la view-uri sau la Activity.

52 Junior

De ce supraviețuiește un ViewModel rotirii ecranului și când este distrus?

Răspuns scurt: ViewModel-ul e păstrat într-un ViewModelStore asociat cu Activity-ul sau Fragment-ul, iar acest store e transferat instanței noi la o schimbare de configurație. E distrus și primește onCleared() doar când owner-ul dispare definitiv, de exemplu la finish() sau când ecranul e scos din back stack.

Când obții un ViewModel prin by viewModels(), hiltViewModel() sau ViewModelProvider, nu îl creezi direct. Ceri unui ViewModelProvider instanța asociată cu un ViewModelStoreOwner (Activity, Fragment sau o destinație din Navigation). Dacă există deja în ViewModelStore, o primești pe aceeași; altfel, se creează una nouă.

La rotire, sistemul distruge Activity-ul, dar ComponentActivity păstrează ViewModelStore printr-un mecanism intern pentru schimbări de configurație (non-configuration instance). Noul Activity primește același store, deci și aceleași ViewModel-uri.

ViewModel-ul e distrus când:

  • Activity-ul se închide definitiv (back, finish()), adică nu e o schimbare de configurație;
  • Fragment-ul e eliminat definitiv;
  • destinația de navigare e scoasă din back stack.

Atunci se apelează onCleared(), iar viewModelScope e anulat.

KOTLIN
class TimerViewModel : ViewModel() {
    private val job = viewModelScope.launch { /* ... */ }
    override fun onCleared() {
        // eliberezi resurse care nu sunt legate de viewModelScope
    }
}

Ce nu face ViewModel-ul: nu supraviețuiește morții procesului. Pentru asta folosești SavedStateHandle.

Scope-ul contează: un ViewModel obținut cu by activityViewModels() într-un Fragment e partajat de toate fragmentele din Activity, util pentru un flux în mai mulți pași. În Navigation, poți lega un ViewModel de un graf de navigare, ca să fie comun ecranelor dintr-un subflux. Niciodată nu creezi ViewModel-ul cu constructorul direct (MyViewModel()), pentru că atunci nu mai e reținut de store și pierzi tot avantajul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanismul, nu doar efectul. Greșeala frecventă e confuzia dintre rotire și process death.

53 Junior

Ce este pattern-ul Repository și ce problemă rezolvă?

Răspuns scurt: Repository-ul e o clasă care ascunde sursele de date (API, bază de date, cache) în spatele unei interfețe simple. ViewModel-ul cere „produsele”, iar repository-ul decide de unde le ia și cum le sincronizează, deci restul aplicației nu depinde de detaliile de stocare.

Fără repository, ViewModel-ul ar apela direct Retrofit și Room și ar decide singur când să citească din cache. Aceeași logică s-ar repeta în fiecare ViewModel care are nevoie de produse.

Repository-ul centralizează accesul la un tip de date:

KOTLIN
interface ProductRepository {
    fun observeProducts(): Flow<List<Product>>
    suspend fun refresh()
}

class DefaultProductRepository @Inject constructor(
    private val api: ProductApi,
    private val dao: ProductDao,
    @IoDispatcher private val io: CoroutineDispatcher
) : ProductRepository {

    override fun observeProducts(): Flow<List<Product>> =
        dao.observeAll().map { list -> list.map { it.toDomain() } }

    override suspend fun refresh() = withContext(io) {
        val remote = api.getProducts()
        dao.upsertAll(remote.map { it.toEntity() })
    }
}

Ce câștigi:

  • o singură sursă de adevăr: UI-ul observă baza de date, iar rețeaua doar o actualizează;
  • mapare între modele: DTO-ul din rețea și entitatea Room sunt transformate în modelul de domeniu, iar UI-ul nu depinde de forma JSON-ului;
  • testare: ViewModel-ul depinde de interfața ProductRepository, deci în teste îi dai un fake în memorie;
  • schimbare ușoară: dacă înlocuiești Retrofit sau adaugi un cache, modifici un singur loc.

Repository-urile ar trebui să fie main-safe (să poată fi apelate de pe orice thread) și să expună funcții suspend pentru operații unice și Flow pentru date observabile. Evită un singur „AppRepository” uriaș pentru toată aplicația; fă câte unul pe domeniu (produse, utilizator, comenzi).

Ce urmărește intervievatorul: Se verifică dacă știi de ce există stratul de date și dacă înțelegi ideea de sursă unică de adevăr.

54 Junior

Ce este dependency injection și de ce l-ai folosi într-o aplicație Android?

Răspuns scurt: Dependency injection înseamnă că o clasă își primește dependențele din exterior, de obicei prin constructor, în loc să le creeze singură. Codul devine ușor de testat, cu fake-uri în locul dependențelor reale, și mai puțin cuplat de implementări.

Compară cele două variante:

KOTLIN
// fără DI: clasa își creează singură dependențele
class OrderViewModel : ViewModel() {
    private val repo = OrderRepository(RetrofitClient.api, AppDatabase.get().orderDao())
}

// cu DI: dependențele vin din exterior
class OrderViewModel(private val repo: OrderRepository) : ViewModel()

În prima variantă, ca să testezi ViewModel-ul ai nevoie de rețea reală și de o bază de date. Nu poți simula o eroare de server. În a doua, în test scrii OrderViewModel(FakeOrderRepository(fail = true)).

Formele de injectare:

  • prin constructor: cea preferată; dependențele sunt evidente și obiectul e complet la creare;
  • prin câmp (field injection): necesară pentru clasele create de sistem, ca Activity sau Fragment, unde nu controlezi constructorul;
  • prin metodă: rar.

Poți face DI manual, cu o clasă AppContainer care creează și leagă obiectele. Pentru o aplicație mică merge bine. Pe măsură ce crește, devine mult cod repetitiv, iar gestionarea duratelor de viață (un singur client HTTP pe aplicație, un obiect pe ecran) se complică. De aceea se folosesc biblioteci: Hilt (construit peste Dagger, recomandat de Google, verificat la compilare) sau Koin (un service locator cu sintaxă Kotlin, configurat la rulare).

DI nu e un scop în sine: principiul de bază e ca o clasă să depindă de abstracții și să nu știe cum se construiesc obiectele de care are nevoie.

Ce urmărește intervievatorul: Intervievatorul vrea să audă argumentul testării, nu doar „pentru că așa se face”. Un plus e să știi că DI se poate face și manual.

55 Junior

Care sunt adnotările de bază din Hilt și ce face fiecare?

Răspuns scurt: @HiltAndroidApp pe clasa Application pornește generarea containerului, @AndroidEntryPoint permite injectarea în Activity și Fragment, @HiltViewModel cu @Inject constructor face ViewModel-ul injectabil, iar @Module cu @InstallIn descrie cum se creează dependențele pe care Hilt nu le poate construi singur.

Hilt generează la compilare codul Dagger necesar, pe baza adnotărilor:

KOTLIN
@HiltAndroidApp
class App : Application()

@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    private val viewModel: HomeViewModel by viewModels()
}

@HiltViewModel
class HomeViewModel @Inject constructor(
    private val repo: NewsRepository
) : ViewModel()

class NewsRepository @Inject constructor(private val api: NewsApi)

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides @Singleton
    fun provideRetrofit(): Retrofit = Retrofit.Builder()
        .baseUrl("https://api.exemplu.ro/")
        .addConverterFactory(MoshiConverterFactory.create())
        .build()

    @Provides
    fun provideNewsApi(retrofit: Retrofit): NewsApi = retrofit.create(NewsApi::class.java)
}

Pe scurt:

  • @Inject constructor: îi spune lui Hilt cum să creeze clasa. Pentru clasele tale, de obicei asta e suficient.
  • @Module + @InstallIn(Component): pentru tipuri pe care nu le poți adnota (Retrofit, Room, interfețe). @InstallIn decide în ce container trăiește modulul (SingletonComponent, ViewModelComponent, ActivityComponent).
  • @Provides: o funcție care construiește obiectul.
  • @Singleton: o singură instanță pe aplicație.
  • @ApplicationContext: injectează contextul aplicației.

În Compose obții ViewModel-ul cu hiltViewModel() din hilt-navigation-compose. Hilt folosește procesarea adnotărilor, iar proiectele noi rulează procesorul prin KSP, care e mai rapid decât kapt. Avantajul principal față de soluțiile la rulare: dacă lipsește o dependență, află compilatorul, nu utilizatorul.

Ce urmărește intervievatorul: Se verifică experiența practică cu Hilt. Mulți candidați nu știu de ce ai nevoie de @Module pentru interfețe sau clase din biblioteci.

56 Mid

Ce înseamnă flux unidirecțional al datelor (UDF) și cum tratezi evenimentele de o singură dată, cum ar fi un Snackbar sau o navigare?

Răspuns scurt: În UDF, starea curge din ViewModel spre UI, iar evenimentele merg invers. Efectele de o singură dată se modelează, după recomandarea Google, tot ca stare pe care UI-ul o consumă și o confirmă; alternativa frecventă e un Channel.

Fluxul arată așa: utilizatorul apasă un buton, UI-ul apelează viewModel.onSave(), ViewModel-ul actualizează starea, iar UI-ul se redesenează din noua stare. UI-ul nu își modifică singur starea și nu decide logica.

Problema apare la efecte care trebuie să se întâmple o singură dată: afișarea unui mesaj, navigarea după salvare. Dacă le pui ca simplu câmp într-un StateFlow (showSaved = true), la rotire UI-ul primește din nou starea și afișează mesajul a doua oară.

Varianta 1, recomandată în ghidul de arhitectură Android: efectul face parte din stare, iar UI-ul anunță că l-a consumat.

KOTLIN
data class EditUiState(val saving: Boolean = false, val userMessage: String? = null)

fun onSave() = viewModelScope.launch {
    repo.save()
    _state.update { it.copy(userMessage = "Salvat") }
}
fun onMessageShown() = _state.update { it.copy(userMessage = null) }

// UI
state.userMessage?.let { msg ->
    LaunchedEffect(msg) {
        snackbarHostState.showSnackbar(msg)
        viewModel.onMessageShown()
    }
}

Varianta 2: un Channel<Event>(Channel.BUFFERED) expus cu receiveAsFlow(). Fiecare eveniment e livrat unui singur colector, iar dacă UI-ul nu colectează, evenimentele așteaptă în buffer. Riscul e că un eveniment poate fi pierdut dacă e trimis exact în timpul unei schimbări de configurație; colectarea pe Dispatchers.Main.immediate reduce acest risc.

SharedFlow fără replay e cea mai riscantă variantă: dacă nimeni nu colectează în acel moment, evenimentul se pierde. Pentru navigare, multe echipe preferă tot starea, de exemplu isSaved = true, la care ecranul reacționează navigând.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai întâlnit problema evenimentelor duplicate la rotire și dacă știi compromisurile fiecărei soluții.

57 Mid

Ce este Clean Architecture în contextul Android și ce rol au use case-urile?

Răspuns scurt: Clean Architecture împarte aplicația în straturi (UI, domeniu, date), cu dependențe orientate spre interior: domeniul nu depinde de Android sau de biblioteci. Use case-urile (interactors) sunt clase mici în stratul de domeniu, care conțin o singură operație de business refolosibilă, de exemplu PlaceOrderUseCase.

Ideea centrală: logica de business nu trebuie să știe dacă datele vin din Retrofit sau din Room și nici dacă UI-ul e în Compose. Straturile tipice:

  • UI (prezentare): composable-uri și ViewModel-uri;
  • domeniu: modele de business, interfețe de repository și use case-uri. Ideal e Kotlin pur, fără dependențe de Android;
  • date: implementări de repository, surse de date, DTO-uri, entități.

Dependențele merg spre domeniu: stratul de date implementează interfețele definite în domeniu (inversarea dependențelor).

KOTLIN
class GetCartTotalUseCase @Inject constructor(
    private val cart: CartRepository,
    private val promotions: PromotionRepository
) {
    operator fun invoke(): Flow<Money> =
        combine(cart.observeItems(), promotions.observeActive()) { items, promos ->
            val subtotal = items.sumOf { it.price * it.quantity }
            promos.fold(subtotal) { total, p -> p.apply(total) }.let(::Money)
        }
}

// în ViewModel
val total = getCartTotal().stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), Money.ZERO)

Cu operator fun invoke, use case-ul se apelează ca o funcție. Un use case are sens când logica e folosită de mai multe ViewModel-uri sau combină mai multe repository-uri.

Ghidul oficial Android numește stratul de domeniu „opțional”. Pentru o aplicație mică, use case-uri care doar apelează repository.getX() adaugă straturi fără valoare. Un răspuns matur arată că aplici structura în funcție de complexitate: ViewModel plus repository la început, și extragi use case-uri când apare logică duplicată sau complexă.

Separarea în module Gradle (:domain, :data) face granițele obligatorii, pentru că compilatorul nu permite importuri greșite.

Ce urmărește intervievatorul: Se verifică dacă înțelegi direcția dependențelor și dacă știi când straturile suplimentare nu merită. Răspunsul dogmatic e un semnal slab.

58 Mid

Ce sunt scope-urile în Hilt și care e diferența dintre @Binds și @Provides?

Răspuns scurt: Un scope (de exemplu @Singleton, @ActivityScoped, @ViewModelScoped) leagă o instanță de durata de viață a unei componente Hilt, deci primești același obiect cât trăiește acea componentă. @Binds leagă o interfață de implementarea ei fără cod suplimentar; @Provides conține o funcție care construiește obiectul.

Implicit, Hilt creează o instanță nouă la fiecare injectare (unscoped). Cu un scope, instanța e memorată în componenta corespunzătoare:

  • @Singleton în SingletonComponent: o instanță pe aplicație (client HTTP, bază de date);
  • @ActivityRetainedScoped: supraviețuiește rotirii, cât Activity-ul nu e închis definitiv;
  • @ViewModelScoped în ViewModelComponent: partajat de dependențele unui singur ViewModel;
  • @ActivityScoped, @FragmentScoped: legate de acele componente.

Un scope are un cost: obiectul e ținut în memorie și accesul trece printr-un mecanism sincronizat. Pune scope doar unde ai nevoie de stare partajată sau unde crearea e scumpă.

KOTLIN
@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {
    @Binds @Singleton
    abstract fun bindProductRepository(impl: DefaultProductRepository): ProductRepository
}

@Module
@InstallIn(SingletonComponent::class)
object DatabaseModule {
    @Provides @Singleton
    fun provideDb(@ApplicationContext ctx: Context): AppDatabase =
        Room.databaseBuilder(ctx, AppDatabase::class.java, "app.db").build()

    @Provides
    fun provideProductDao(db: AppDatabase): ProductDao = db.productDao()
}

@Binds e o funcție abstractă: implementarea are deja @Inject constructor, iar tu doar spui „când cineva cere interfața, dă-i asta”. Generează mai puțin cod decât un @Provides echivalent. @Provides e necesar când construiești obiectul cu un builder sau când tipul vine dintr-o bibliotecă.

Pentru mai multe implementări ale aceluiași tip folosești calificatori (@Qualifier, de exemplu @IoDispatcher și @DefaultDispatcher). O greșeală frecventă: o dependență cu scope mai scurt injectată într-una cu scope mai lung, pe care Hilt o refuză la compilare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că implicit nu există scope și dacă alegi @Binds pentru interfețe.

59 Mid

Care e diferența dintre MVVM și MVI?

Răspuns scurt: Ambele separă UI-ul de logică. În MVI, ecranul are o singură stare imuabilă, iar acțiunile sunt trimise ca obiecte „intent” printr-un singur punct de intrare. În MVVM, ViewModel-ul expune funcții și poate avea mai multe fluxuri de stare.

În MVVM clasic, ViewModel-ul expune mai multe proprietăți observabile (name, isLoading, items) și funcții publice (onRefresh(), onDelete(id)). E simplu și direct, dar pe ecrane complexe stările pot ajunge inconsistente: isLoading = true și error != null în același timp.

În MVI:

  • o singură stare pentru ecran, de obicei o data class imuabilă;
  • intenții: toate acțiunile sunt tipuri dintr-un sealed interface;
  • reducer: o funcție pură (state, result) -> newState;
  • efectele de o singură dată sunt separate (side effects).
KOTLIN
sealed interface CartIntent {
    data class Add(val id: Long) : CartIntent
    data class Remove(val id: Long) : CartIntent
    data object Checkout : CartIntent
}

class CartViewModel(private val repo: CartRepository) : ViewModel() {
    private val _state = MutableStateFlow(CartState())
    val state = _state.asStateFlow()

    fun onIntent(intent: CartIntent) {
        when (intent) {
            is CartIntent.Add -> _state.update { it.copy(items = it.items + intent.id) }
            is CartIntent.Remove -> _state.update { it.copy(items = it.items - intent.id) }
            CartIntent.Checkout -> viewModelScope.launch { repo.checkout(_state.value.items) }
        }
    }
}

Avantajele MVI: stare previzibilă, ușor de logat și de reprodus, teste simple pe reducer. Dezavantajele: mai mult cod repetitiv, iar pentru ecrane simple pare birocratic.

În practică, multe echipe folosesc un hibrid: MVVM cu o singură clasă de stare per ecran și flux unidirecțional, adică exact ce recomandă ghidul Android. La interviu contează să explici compromisurile și să spui ce ai folosit și de ce, nu să declari un câștigător.

Ce urmărește intervievatorul: Se verifică dacă înțelegi diferențele reale și compromisurile. Răspunsul slab e o listă de definiții fără context.

60 Senior

Cum ai modulariza o aplicație Android mare și ce beneficii și costuri aduce modularizarea?

Răspuns scurt: Aș împărți codul în module Gradle după funcționalitate (:feature:cart, :feature:profile) și module comune (:core:data, :core:ui, :core:network). Câștigi build-uri incrementale mai rapide, granițe clare și lucru în paralel; plătești cu configurare Gradle mai complexă și cu nevoia de a gândi dependențele între module.

Un singur modul :app cu sute de mii de linii înseamnă că orice schimbare recompilează mult, oricine poate importa orice, iar dependențele circulare apar fără să le observe cineva.

O structură frecventă, folosită și în proiectul de referință „Now in Android” de la Google:

:app                    -> punctul de intrare, NavHost, DI la nivel de aplicație
:feature:cart           -> ecranele și ViewModel-urile coșului
:feature:profile
:core:ui                -> design system, componente Compose comune
:core:data              -> repository-uri
:core:database          -> Room
:core:network           -> Retrofit, DTO-uri
:core:model             -> modele de domeniu, Kotlin pur
:build-logic            -> convention plugins pentru configurarea comună

Reguli importante:

  • modulele feature nu depind unele de altele. Navigarea între ele se face prin rute definite într-un modul API sau prin :app, care le leagă;
  • modulele core nu depind de feature;
  • folosește implementation în loc de api în Gradle, ca dependențele să nu se scurgă și schimbările să nu recompileze tot;
  • configurarea comună (versiune SDK, Compose, Hilt) se pune în convention plugins, nu se copiază în fiecare build.gradle.kts.

Beneficii: compilare incrementală și în paralel mai rapidă, cod de test izolat, echipe care lucrează pe module diferite fără conflicte, posibilitatea de feature modules livrate la cerere (Play Feature Delivery).

Costuri: mai multe fișiere de configurare, sincronizare Gradle mai lentă dacă ai prea multe module mici, decizii mai grele despre unde stă codul comun. Nu modularizez de la prima zi o aplicație mică; încep când timpul de build sau conflictele dintre echipe devin o problemă reală și măsurabilă.

Ce urmărește intervievatorul: La senior se verifică experiența cu structuri reale și cu Gradle. Semnalul bun e că pomenești costurile și momentul potrivit.

61 Senior

Cum ai proiecta o aplicație offline-first, în care utilizatorul poate lucra fără conexiune?

Răspuns scurt: Baza de date locală devine sursa unică de adevăr: UI-ul citește doar din Room, scrierile se fac întâi local, cu o marcă „nesincronizat”, iar un worker WorkManager trimite schimbările la server când apare conexiunea. Trebuie definită și o strategie pentru conflicte.

În modelul online-first, ecranul face un request și afișează rezultatul; fără rețea, nu afișează nimic. Offline-first inversează rolurile.

Citirea: UI-ul observă Flow-uri din Room. Repository-ul pornește un refresh din rețea și scrie rezultatul în Room, iar UI-ul se actualizează singur. Fără rețea, utilizatorul vede ultimele date sincronizate, eventual cu un indicator „actualizat acum 2 ore”.

Scrierea: salvezi local imediat, cu un câmp de stare.

KOTLIN
@Entity
data class NoteEntity(
    @PrimaryKey val id: String = UUID.randomUUID().toString(),
    val text: String,
    val updatedAt: Long,
    val syncState: SyncState = SyncState.PENDING
)

class NoteRepository @Inject constructor(private val dao: NoteDao, private val work: WorkManager) {
    suspend fun save(text: String) {
        dao.upsert(NoteEntity(text = text, updatedAt = System.currentTimeMillis()))
        work.enqueueUniqueWork("sync-notes", ExistingWorkPolicy.KEEP,
            OneTimeWorkRequestBuilder<SyncWorker>()
                .setConstraints(Constraints(requiredNetworkType = NetworkType.CONNECTED)).build())
    }
}

ID-urile generate pe client (UUID) evită problema „ce ID primește înregistrarea până răspunde serverul”.

Sincronizarea: SyncWorker trimite înregistrările PENDING, apoi le marchează SYNCED, și aduce schimbările de pe server de la ultimul timestamp sau token de sincronizare. Operațiile trebuie să fie idempotente, pentru că un worker poate rula de mai multe ori.

Conflicte: cea mai simplă strategie e „ultima scriere câștigă”, pe baza timestamp-ului de pe server. Pentru date colaborative ai nevoie de reguli pe câmp sau de intervenția utilizatorului. Ștergerile se marchează (soft delete) până sunt sincronizate.

Decizia trebuie luată cu echipa de backend, pentru că API-ul trebuie să suporte sincronizare incrementală.

Ce urmărește intervievatorul: Se verifică gândirea de sistem: sursa de adevăr, idempotența și conflictele. Răspunsul slab e „pun un cache”.

62 Senior

Cum ai implementa un feed cu paginare infinită care se încarcă din API pe măsură ce utilizatorul derulează?

Răspuns scurt: Aș folosi Paging 3: un PagingSource care încarcă paginile din API (sau un RemoteMediator care le salvează în Room pentru suport offline), un Pager în repository care expune Flow<PagingData>, cachedIn(viewModelScope) în ViewModel și collectAsLazyPagingItems() în Compose.

Implementarea manuală (detectezi finalul listei, încarci pagina următoare, gestionezi încărcările duplicate, erorile și refresh-ul) e posibilă, dar plină de cazuri limită. Paging 3 le rezolvă pe toate.

KOTLIN
class PostsPagingSource(private val api: PostsApi) : PagingSource<String, PostDto>() {
    override suspend fun load(params: LoadParams<String>): LoadResult<String, PostDto> = try {
        val page = api.getPosts(cursor = params.key, limit = params.loadSize)
        LoadResult.Page(data = page.items, prevKey = null, nextKey = page.nextCursor)
    } catch (e: IOException) {
        LoadResult.Error(e)
    }
    override fun getRefreshKey(state: PagingState<String, PostDto>): String? = null
}

// repository
fun posts(): Flow<PagingData<PostDto>> =
    Pager(PagingConfig(pageSize = 20, prefetchDistance = 5)) { PostsPagingSource(api) }.flow

// ViewModel
val posts = repo.posts().cachedIn(viewModelScope)

// UI
val items = viewModel.posts.collectAsLazyPagingItems()
LazyColumn {
    items(count = items.itemCount, key = items.itemKey { it.id }) { i ->
        items[i]?.let { PostRow(it) }
    }
}

Decizii de proiectare de discutat:

  • paginare cu cursor vs offset: cu offset, dacă apar elemente noi în timp ce derulezi, primești duplicate sau sari elemente. Cursorul (ID-ul ultimului element) e mai robust. Asta se negociază cu backend-ul.
  • offline: cu RemoteMediator, paginile se scriu în Room, iar UI-ul citește din PagingSource-ul generat de Room, deci ai și cache.
  • stări: items.loadState îți spune dacă e încărcare, eroare la refresh sau la append, ca să arăți un spinner sau un buton „Reîncearcă” la finalul listei.
  • cachedIn e obligatoriu, altfel la rotire lista se reîncarcă de la zero.

Pentru acțiuni precum „like”, nu modifici PagingData direct; actualizezi sursa (Room) sau combini cu o stare locală.

Ce urmărește intervievatorul: Întrebare de system design la scară mică. Se verifică dacă ridici problemele de cursor vs offset, offline și stări de eroare.

Date și rețea: Room, Retrofit și SQL

63 Junior

Când folosești SharedPreferences, DataStore și Room pentru a salva date local?

Răspuns scurt: Pentru setări simple și puține valori (tema, un flag), folosești DataStore, înlocuitorul modern al SharedPreferences. Pentru date structurate, liste, relații sau interogări, folosești Room. SharedPreferences rămâne în codul vechi, dar are API sincron care poate bloca thread-ul principal.

SharedPreferences a fost mult timp soluția pentru perechi cheie-valoare. Problemele lui: citirea inițială e sincronă și poate bloca main-ul, commit() blochează, apply() poate provoca ANR-uri la oprirea Activity-ului, iar erorile de parsare apar ca excepții la rulare.

DataStore (Jetpack) rezolvă asta:

  • API bazat pe coroutines și Flow, complet asincron;
  • scrieri tranzacționale, consistente;
  • două variante: Preferences DataStore (chei tipizate, fără schemă) și Proto/typed DataStore (un obiect serializat, de exemplu cu kotlinx.serialization sau Protocol Buffers).
KOTLIN
val Context.settings by preferencesDataStore(name = "settings")
private val DARK = booleanPreferencesKey("dark_mode")

class SettingsRepository(private val context: Context) {
    val darkMode: Flow<Boolean> = context.settings.data.map { it[DARK] ?: false }
    suspend fun setDarkMode(value: Boolean) {
        context.settings.edit { it[DARK] = value }
    }
}

DataStore citește și scrie tot fișierul la fiecare modificare, deci nu e făcut pentru volume mari sau date pe care vrei să le interoghezi. Și nu trebuie creat mai mult de un DataStore pentru același fișier în același proces.

Room e pentru date structurate: liste de produse, mesaje, orice ai filtra, sorta sau relaționa. Îți oferă SQL verificat la compilare, migrații și Flow-uri care se actualizează la modificări.

Pentru fișiere mari (imagini, PDF-uri) folosești stocarea internă a aplicației (filesDir, cacheDir) și ții în Room doar calea. Pentru date sensibile, ca token-urile, ai grijă suplimentar (criptare cu Android Keystore).

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi stocarea după tipul datelor și dacă știi problemele lui SharedPreferences.

64 Junior

Care sunt componentele principale ale Room și ce face fiecare?

Răspuns scurt: Room are trei componente: @Entity (o clasă care devine tabel), @Dao (interfața cu metodele de acces, adnotate cu @Query, @Insert, @Update, @Delete) și @Database (clasa abstractă care leagă entitățile și DAO-urile și oferă conexiunea). Room generează implementarea la compilare și verifică interogările SQL.

Room e un strat de abstracție peste SQLite. Scrii SQL, dar primești verificare la compilare și maparea automată în obiecte Kotlin.

KOTLIN
@Entity(tableName = "tasks")
data class TaskEntity(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val title: String,
    val done: Boolean = false,
    @ColumnInfo(name = "due_at") val dueAt: Long?
)

@Dao
interface TaskDao {
    @Query("SELECT * FROM tasks WHERE done = 0 ORDER BY due_at")
    fun observePending(): Flow<List<TaskEntity>>

    @Upsert
    suspend fun upsert(task: TaskEntity)

    @Query("UPDATE tasks SET done = 1 WHERE id = :id")
    suspend fun markDone(id: Long)

    @Delete
    suspend fun delete(task: TaskEntity)
}

@Database(entities = [TaskEntity::class], version = 1, exportSchema = true)
abstract class AppDatabase : RoomDatabase() {
    abstract fun taskDao(): TaskDao
}

Ce merită spus la interviu:

  • dacă greșești numele unei coloane în @Query, proiectul nu compilează. E un avantaj mare față de SQLite folosit direct;
  • metodele suspend sunt main-safe: Room le rulează singur pe un executor de fundal. Room nu permite implicit interogări sincrone pe thread-ul principal;
  • o metodă care returnează Flow emite din nou ori de câte ori se modifică tabelele implicate;
  • @Upsert (din Room 2.5) inserează sau actualizează;
  • tipurile pe care SQLite nu le cunoaște (de exemplu Instant) se convertesc cu @TypeConverter;
  • baza de date se creează o singură dată pe aplicație (singleton prin Hilt), pentru că deschiderea e costisitoare.

exportSchema = true salvează schema în fișiere JSON, utile pentru migrații și pentru testarea lor. Versiunile recente de Room (2.7+) sunt scrise în Kotlin și suportă și Kotlin Multiplatform.

Ce urmărește intervievatorul: Se verifică dacă ai folosit Room în practică. Un plus e să menționezi verificarea la compilare și Flow-urile reactive.

65 Junior

Cum faci un request HTTP cu Retrofit? Descrie pașii.

Răspuns scurt: Definești o interfață cu metode adnotate (@GET, @POST, @Path, @Query, @Body), construiești o instanță Retrofit cu URL-ul de bază și un convertor JSON, apoi obții implementarea cu retrofit.create(). Metodele marcate suspend se apelează direct din corutine.

Retrofit transformă o interfață Kotlin într-un client HTTP. În spate folosește OkHttp pentru conexiuni.

KOTLIN
@Serializable
data class RepoDto(val id: Long, val name: String, val stargazers_count: Int)

interface GitHubApi {
    @GET("users/{user}/repos")
    suspend fun repos(
        @Path("user") user: String,
        @Query("sort") sort: String = "updated"
    ): List<RepoDto>

    @POST("issues")
    suspend fun createIssue(@Body body: NewIssueDto): Response<IssueDto>
}

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .client(OkHttpClient.Builder().build())
    .addConverterFactory(Json { ignoreUnknownKeys = true }.asConverterFactory("application/json".toMediaType()))
    .build()

val api = retrofit.create(GitHubApi::class.java)

Detalii care contează:

  • baseUrl trebuie să se termine cu /, altfel Retrofit aruncă excepție;
  • @Path înlocuiește o parte din cale, @Query adaugă parametri ?sort=updated, @Body serializează obiectul în corpul cererii, @Header adaugă antete;
  • dacă metoda returnează direct tipul (List<RepoDto>), un cod HTTP 4xx sau 5xx aruncă HttpException. Dacă returnează Response<T>, primești codul, antetele și corpul și decizi tu;
  • erorile de rețea (fără conexiune, timeout) sunt IOException;
  • convertorul pentru kotlinx.serialization e inclus în Retrofit începând cu versiunea 2.11; alternative frecvente sunt Moshi și Gson;
  • ai nevoie de permisiunea INTERNET în manifest.

Instanța de Retrofit și OkHttpClient se creează o singură dată (singleton), pentru că își păstrează pool-ul de conexiuni și cache-ul. Apelul API nu se face din ViewModel direct, ci printr-un repository.

Ce urmărește intervievatorul: Intervievatorul verifică fluența cu cel mai folosit client HTTP pe Android și dacă știi diferența dintre erori HTTP și erori de rețea.

66 Junior

Cum transformi JSON în obiecte Kotlin și ce probleme apar cu câmpurile lipsă sau null?

Răspuns scurt: Folosești o bibliotecă de serializare: kotlinx.serialization (@Serializable), Moshi sau Gson. Problemele apar când JSON-ul nu se potrivește cu modelul: câmpuri lipsă, null neașteptat sau câmpuri necunoscute. Le rezolvi cu valori implicite, tipuri nullable și opțiuni precum ignoreUnknownKeys.

kotlinx.serialization e biblioteca oficială JetBrains. Generează serializatorii la compilare, printr-un plugin, deci nu folosește reflexie și respectă null safety-ul Kotlin.

KOTLIN
@Serializable
data class UserDto(
    val id: Long,
    val name: String,
    @SerialName("avatar_url") val avatarUrl: String? = null,
    val roles: List<String> = emptyList()
)

val json = Json {
    ignoreUnknownKeys = true   // nu crapă dacă serverul adaugă câmpuri noi
    coerceInputValues = true   // null pe un câmp non-null cu valoare implicită -> folosește valoarea implicită
}

// body = {"id":1,"name":"Ana","extra":true}
val user = json.decodeFromString<UserDto>(body)

Situațiile frecvente:

  • câmp lipsă: dacă proprietatea nu are valoare implicită, primești MissingFieldException. Dă valori implicite câmpurilor opționale;
  • null pe un câmp non-null: excepție, cu excepția cazului în care tipul e nullable sau folosești coerceInputValues cu valoare implicită;
  • câmpuri necunoscute: implicit eroare în kotlinx.serialization; de aceea ignoreUnknownKeys = true e aproape mereu activat în aplicații;
  • nume diferite: @SerialName (sau @Json(name = ...) în Moshi).

Gson, încă prezent în multe proiecte vechi, folosește reflexie și nu cunoaște null safety: poate pune null într-un String non-null, iar eroarea apare mai târziu, într-un loc greu de legat de cauză. De asta proiectele noi preferă kotlinx.serialization sau Moshi cu codegen.

Bună practică: DTO-urile din rețea sunt separate de modelele de domeniu. Le mapezi explicit, iar acolo decizi ce faci cu valorile lipsă, în loc să lași nullable-urile să ajungă până în UI.

Ce urmărește intervievatorul: Se verifică dacă ai avut de-a face cu API-uri reale, care se schimbă. Un plus e să știi de ce Gson poate încălca null safety.

67 Junior

Scrie o interogare SQL care afișează, pentru fiecare utilizator, numele și numărul de comenzi, inclusiv utilizatorii fără comenzi.

Răspuns scurt: Folosești un LEFT JOIN între users și orders, grupezi după utilizator și numeri cu COUNT(o.id), nu cu COUNT(*), astfel încât utilizatorii fără comenzi să apară cu 0.

Presupunem tabelele users(id, name) și orders(id, user_id, total).

SQL
SELECT u.id, u.name, COUNT(o.id) AS order_count
FROM users u
LEFT JOIN orders o ON o.user_id = u.id
GROUP BY u.id, u.name
ORDER BY order_count DESC;

De ce fiecare alegere:

  • LEFT JOIN păstrează toți utilizatorii din tabela din stânga, chiar dacă nu au nicio comandă. Un INNER JOIN i-ar elimina, iar cerința spune explicit „inclusiv utilizatorii fără comenzi”.
  • Pentru un utilizator fără comenzi, rândul rezultat are NULL în toate coloanele din orders.
  • COUNT(o.id) numără doar valorile non-null, deci dă 0 pentru acești utilizatori. COUNT(*) numără rânduri, iar rezultatul ar fi 1, greșit.
  • GROUP BY u.id, u.name: grupăm după ID, nu doar după nume, pentru că pot exista doi utilizatori cu același nume.

Variante frecvente la interviu:

  • „doar utilizatorii cu mai mult de 3 comenzi”: adaugi HAVING COUNT(o.id) > 3;
  • „și suma totală”: COALESCE(SUM(o.total), 0), pentru că SUM peste nimic dă NULL.

În Room, poți mapa direct rezultatul într-o clasă care nu e entitate:

KOTLIN
data class UserOrders(val id: Long, val name: String, @ColumnInfo(name = "order_count") val orderCount: Int)

@Query("SELECT u.id, u.name, COUNT(o.id) AS order_count FROM users u LEFT JOIN orders o ON o.user_id = u.id GROUP BY u.id, u.name")
fun observeUserOrders(): Flow<List<UserOrders>>

Room verifică la compilare că numele coloanelor din rezultat se potrivesc cu proprietățile clasei.

Ce urmărește intervievatorul: Exercițiu clasic de SQL. Se verifică diferența LEFT/INNER JOIN și capcana COUNT(*) vs COUNT(coloană).

68 Junior

Ce este un index într-o bază de date și când adaugi unul într-o entitate Room?

Răspuns scurt: Un index e o structură suplimentară, de obicei un B-tree, care găsește rapid rândurile după anumite coloane, fără scanarea întregii tabele. Îl pui pe coloanele din WHERE, JOIN sau ORDER BY, cu costul unor scrieri mai lente.

Fără index, o interogare SELECT * FROM messages WHERE chat_id = 42 trebuie să citească fiecare rând din tabelă (full table scan). Pentru câteva sute de rânduri nu contează; pentru zeci de mii de mesaje, diferența se simte în UI.

Un index pe chat_id funcționează ca indexul de la finalul unei cărți: SQLite găsește direct rândurile cu valoarea căutată.

KOTLIN
@Entity(
    tableName = "messages",
    indices = [
        Index(value = ["chat_id", "sent_at"]),
        Index(value = ["remote_id"], unique = true)
    ],
    foreignKeys = [ForeignKey(
        entity = ChatEntity::class,
        parentColumns = ["id"],
        childColumns = ["chat_id"],
        onDelete = ForeignKey.CASCADE
    )]
)
data class MessageEntity(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    @ColumnInfo(name = "chat_id") val chatId: Long,
    @ColumnInfo(name = "remote_id") val remoteId: String,
    @ColumnInfo(name = "sent_at") val sentAt: Long,
    val text: String
)

Câteva reguli:

  • cheia primară e indexată automat;
  • un index compus (chat_id, sent_at) servește interogările care filtrează după chat_id și sortează după sent_at. Ordinea coloanelor contează: poate fi folosit pentru chat_id singur, dar nu pentru sent_at singur;
  • un index unic garantează că nu apar duplicate, de exemplu același mesaj primit de două ori de la server;
  • pentru cheile străine, Room afișează un avertisment dacă coloana copil nu e indexată, pentru că altfel fiecare ștergere în tabela părinte ar scana tabela copil.

Costul: fiecare inserare actualizează și indexurile, iar fișierul bazei de date crește. Nu indexa toate coloanele; indexează în funcție de interogările reale. Poți verifica dacă un index e folosit cu EXPLAIN QUERY PLAN.

Ce urmărește intervievatorul: Se verifică înțelegerea compromisului citire/scriere și a indexurilor compuse. Mulți candidați spun „indexez tot” sau nu știu ce face un index.

69 Mid

Cum gestionezi o schimbare de schemă în Room fără să pierzi datele utilizatorilor?

Răspuns scurt: Crești version în @Database și oferi o migrare: fie o Migration(from, to) scrisă manual cu SQL, fie o @AutoMigration pentru schimbări simple, cum ar fi o coloană nouă. Testezi migrarea cu MigrationTestHelper, pe baza schemelor exportate.

Dacă schimbi o entitate și crești versiunea fără migrare, Room aruncă IllegalStateException la deschiderea bazei de date. Soluția comodă, fallbackToDestructiveMigration(), șterge toate datele, ceea ce e acceptabil doar pentru un cache care se poate reîncărca din rețea.

AutoMigrations (din Room 2.4): Room compară schemele exportate și generează migrarea. Funcționează pentru adăugarea de coloane sau tabele. Pentru redenumiri sau ștergeri îi dai indicii printr-o specificație.

KOTLIN
@Database(
    entities = [TaskEntity::class],
    version = 3,
    autoMigrations = [
        AutoMigration(from = 1, to = 2),
        AutoMigration(from = 2, to = 3, spec = Migration2To3::class)
    ]
)
abstract class AppDatabase : RoomDatabase()

@RenameColumn(tableName = "tasks", fromColumnName = "due", toColumnName = "due_at")
class Migration2To3 : AutoMigrationSpec

Necesită exportSchema = true și directorul de scheme configurat în Gradle; fișierele JSON se adaugă în git.

Migrare manuală, când transformi date:

KOTLIN
val MIGRATION_3_4 = object : Migration(3, 4) {
    override fun migrate(db: SupportSQLiteDatabase) {
        db.execSQL("ALTER TABLE tasks ADD COLUMN priority INTEGER NOT NULL DEFAULT 0")
        db.execSQL("UPDATE tasks SET priority = 2 WHERE title LIKE '%urgent%'")
    }
}
Room.databaseBuilder(ctx, AppDatabase::class.java, "app.db").addMigrations(MIGRATION_3_4).build()

SQLite are suport limitat pentru ALTER TABLE; pentru schimbări mai mari creezi o tabelă nouă, copiezi datele, ștergi tabela veche și o redenumești pe cea nouă.

Utilizatorii nu actualizează aplicația la fiecare versiune, deci cineva poate sări de la versiunea 1 direct la 4. Room înlănțuie migrările, dar fiecare trebuie să existe. MigrationTestHelper creează baza de date la o versiune veche, rulează migrarea și verifică schema rezultată.

Ce urmărește intervievatorul: Se verifică dacă ai livrat schimbări de schemă în producție. Răspunsul cu fallbackToDestructiveMigration pentru date de utilizator e un semnal negativ.

70 Mid

Cum modelezi o relație unu-la-mulți în Room și cum o citești eficient?

Răspuns scurt: Pui cheia străină în entitatea copil (de exemplu playlistId în Song), apoi definești o clasă cu @Embedded pentru părinte și @Relation pentru lista de copii. DAO-ul o returnează dintr-o metodă adnotată cu @Transaction, ca cele două interogări să fie consistente.

Room nu permite referințe directe între entități (o entitate nu poate conține o listă de alte entități), tocmai ca să nu încarce leneș date de pe thread-ul principal. Relațiile se descriu explicit.

KOTLIN
@Entity
data class Playlist(@PrimaryKey val playlistId: Long, val name: String)

@Entity(indices = [Index("playlistId")])
data class Song(@PrimaryKey val songId: Long, val playlistId: Long, val title: String)

data class PlaylistWithSongs(
    @Embedded val playlist: Playlist,
    @Relation(parentColumn = "playlistId", entityColumn = "playlistId")
    val songs: List<Song>
)

@Dao
interface PlaylistDao {
    @Transaction
    @Query("SELECT * FROM Playlist")
    fun observeWithSongs(): Flow<List<PlaylistWithSongs>>

    @Transaction
    suspend fun replaceSongs(playlistId: Long, songs: List<Song>) {
        deleteSongs(playlistId)
        insertSongs(songs)
    }

    @Query("DELETE FROM Song WHERE playlistId = :id") suspend fun deleteSongs(id: Long)
    @Insert suspend fun insertSongs(songs: List<Song>)
}

Cum funcționează: Room rulează o interogare pentru playlist-uri și apoi una pentru toate melodiile lor, nu câte una pe playlist, deci evită problema N+1. @Transaction garantează că cele două interogări văd aceeași stare a bazei de date.

Relațiile mulți-la-mulți (un student, mai multe cursuri) folosesc o tabelă de legătură și @Relation cu associateBy = Junction(StudentCourseCrossRef::class).

Alternativa e un JOIN scris manual, cu rezultatul mapat ca Map<Playlist, List<Song>> (suportat din Room 2.4 prin multimap). E util când vrei să filtrezi după câmpuri din ambele tabele.

@Transaction pe o metodă de scriere care apelează mai multe metode DAO face totul atomic: dacă o inserare eșuează, nimic nu se aplică.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi de ce Room nu are lazy loading și dacă folosești @Transaction corect.

71 Mid

Cum adaugi un token de autentificare la toate request-urile și cum tratezi expirarea lui cu OkHttp?

Răspuns scurt: Adaugi antetul Authorization cu un Interceptor OkHttp, iar la un răspuns 401 folosești un Authenticator, care cere un token nou și reîncearcă request-ul. Refresh-ul trebuie sincronizat, ca mai multe request-uri simultane să nu declanșeze mai multe refresh-uri.

Interceptor-ul modifică fiecare request înainte să plece:

KOTLIN
class AuthInterceptor @Inject constructor(private val tokens: TokenStore) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val token = tokens.accessToken()
        val request = chain.request().newBuilder()
            .apply { if (token != null) header("Authorization", "Bearer $token") }
            .build()
        return chain.proceed(request)
    }
}

Authenticator-ul e apelat de OkHttp automat când serverul răspunde cu 401:

KOTLIN
class TokenAuthenticator @Inject constructor(
    private val tokens: TokenStore,
    private val refreshApi: RefreshApi
) : Authenticator {
    override fun authenticate(route: Route?, response: Response): Request? = synchronized(this) {
        if (responseCount(response) >= 2) return null          // evită bucla infinită
        val current = tokens.accessToken()
        val sent = response.request.header("Authorization")?.removePrefix("Bearer ")
        val fresh = if (current != null && current != sent) current   // alt thread a reîmprospătat deja
            else refreshApi.refreshBlocking(tokens.refreshToken())?.also(tokens::save) ?: return null
        response.request.newBuilder().header("Authorization", "Bearer $fresh").build()
    }
    private fun responseCount(r: Response): Int = generateSequence(r) { it.priorResponse }.count()
}

Puncte cheie:

  • authenticate rulează pe thread-ul OkHttp, deci aici e acceptabil un apel sincron. refreshApi folosește un OkHttpClient separat, fără acest authenticator, altfel ar intra în recursivitate;
  • sincronizarea și comparația cu tokenul trimis evită ca cinci request-uri cu 401 să facă cinci refresh-uri;
  • dacă refresh-ul eșuează, returnezi null, iar aplicația deloghează utilizatorul;
  • returnarea null după două încercări oprește bucla.

Mai sunt utile HttpLoggingInterceptor doar în debug (niciodată cu antetele de autentificare logate în release) și timeout-uri configurate explicit.

Ce urmărește intervievatorul: Se verifică experiența cu autentificarea reală și cu concurența la refresh. Răspunsul slab ignoră request-urile simultane.

72 Mid

Cum tratezi erorile de rețea într-un mod pe care UI-ul îl poate afișa clar?

Răspuns scurt: Prinzi excepțiile în stratul de date și le transformi într-un tip propriu (de exemplu sealed interface cu NoConnection, Server, Unauthorized), returnat ca Result sau ca parte din stare. ViewModel-ul mapează eroarea într-un mesaj și o acțiune (reîncercare, login), iar UI-ul doar o afișează.

Dacă lași excepțiile Retrofit să urce până în ViewModel, ajungi cu catch (e: Exception) peste tot și cu mesaje de tipul „HTTP 503” arătate utilizatorului.

Un model mai bun:

KOTLIN
sealed interface AppError {
    data object NoConnection : AppError
    data object Unauthorized : AppError
    data class Server(val code: Int) : AppError
    data class Unknown(val cause: Throwable) : AppError
}

suspend fun <T> safeCall(block: suspend () -> T): Result<T> = try {
    Result.success(block())
} catch (e: CancellationException) {
    throw e
} catch (e: IOException) {
    Result.failure(AppException(AppError.NoConnection))
} catch (e: HttpException) {
    Result.failure(AppException(if (e.code() == 401) AppError.Unauthorized else AppError.Server(e.code())))
}

class AppException(val error: AppError) : Exception()

Observă CancellationException, care e aruncată din nou, ca anularea corutinelor să funcționeze. runCatching simplu ar înghiți-o.

În ViewModel:

KOTLIN
repo.loadOrders()
    .onSuccess { orders -> _state.update { it.copy(orders = orders, error = null) } }
    .onFailure { e ->
        val msg = when ((e as? AppException)?.error) {
            AppError.NoConnection -> R.string.error_offline
            AppError.Unauthorized -> R.string.error_session
            else -> R.string.error_generic
        }
        _state.update { it.copy(error = msg) }
    }

Mesajul e un ID de resursă, nu un text, ca să funcționeze traducerile. Restul sunt decizii de experiență: o eroare de conexiune are buton „Reîncearcă”, o sesiune expirată duce la login, iar dacă există date în cache le arăți împreună cu un banner, nu un ecran gol.

Mai contează timeout-urile rezonabile în OkHttp și reîncercările automate doar pentru operații idempotente (un GET, nu o plată).

Ce urmărește intervievatorul: Intervievatorul verifică dacă gândești erorile ca parte a designului, nu ca excepții prinse la întâmplare.

73 Senior

Ce strategii de cache ai folosi pentru date venite din rețea și cum le ții sincronizate?

Răspuns scurt: Depinde de cât de proaspete trebuie să fie datele: cache HTTP prin OkHttp cu Cache-Control și ETag pentru resurse statice, cache în Room cu „stale-while-revalidate” pentru date afișate des, și sincronizare periodică cu WorkManager pentru date necesare offline. Fiecare are reguli de invalidare explicite.

Nu există o strategie bună pentru toate datele. Pun întrebarea „cât de grav e dacă utilizatorul vede date vechi de 5 minute? de o zi?”.

1. Cache HTTP (OkHttp): configurezi un Cache pe disc pentru client. Dacă serverul trimite Cache-Control: max-age=3600, răspunsul e servit local o oră. Cu ETag, OkHttp trimite If-None-Match, iar serverul răspunde 304 Not Modified fără corp, deci economisești date. Funcționează bine pentru configurări și cataloage, dar depinde de antetele corecte de pe server.

KOTLIN
OkHttpClient.Builder()
    .cache(Cache(File(context.cacheDir, "http"), 20L * 1024 * 1024))
    .build()

2. Stale-while-revalidate în Room: UI-ul afișează imediat ce e în baza de date, repository-ul verifică vârsta datelor și, dacă au trecut mai mult de N minute de la ultimul refresh, pornește unul în fundal. Salvez timestamp-ul ultimei sincronizări pentru fiecare resursă.

KOTLIN
fun observeFeed(): Flow<List<Post>> = dao.observeFeed()
    .onStart { if (clock.now() - meta.lastFeedSync() > 10.minutes) launchRefresh() }

3. Sincronizare periodică: un PeriodicWorkRequest (minimum 15 minute între rulări) pentru date necesare offline, cu constrângeri de rețea și baterie.

4. Push: pentru date care trebuie să fie aproape în timp real, serverul trimite un mesaj Firebase Cloud Messaging care declanșează sincronizarea, în loc de interogări dese.

Invalidarea e partea grea: la logout ștergi tot cache-ul utilizatorului; după o scriere, actualizezi local imediat (optimistic update) și refaci la eroare; versiunea schemei API se ține în cache, ca o actualizare a aplicației să nu citească date într-un format vechi. Limitează mărimea cache-urilor de pe disc, pentru că utilizatorii cu telefoane cu spațiu puțin le simt primii.

Ce urmărește intervievatorul: La senior se verifică dacă alegi strategia după natura datelor și dacă te gândești la invalidare, nu doar la stocare.

74 Senior

Cum stochezi în siguranță date sensibile, cum ar fi un token de acces, și ce alte măsuri de securitate aplici într-o aplicație Android?

Răspuns scurt: Folosești Android Keystore pentru cheile de criptare, astfel încât cheia să nu poată fi extrasă din dispozitiv, și criptezi tokenul înainte să-l salvezi în DataStore. Adaugi HTTPS obligatoriu prin Network Security Config, eventual certificate pinning, R8 pentru ofuscare și eviți logarea datelor sensibile.

Datele din directorul privat al aplicației sunt protejate de sandbox-ul Android pe un dispozitiv normal, dar pe unul cu root sau într-un backup pot fi citite. Pentru tokenuri, chei API ale utilizatorului sau date medicale, ai nevoie de criptare.

Android Keystore generează și păstrează chei în hardware (TEE sau StrongBox, unde există). Aplicația le poate folosi pentru criptare, dar nu le poate exporta.

KOTLIN
val keyGen = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
keyGen.init(
    KeyGenParameterSpec.Builder("token_key",
        KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
        .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
        .build()
)
val key = keyGen.generateKey()

Cu cheia criptezi tokenul (AES-GCM), iar textul cifrat și IV-ul le salvezi în DataStore. Biblioteca Jetpack Security Crypto (EncryptedSharedPreferences) făcea asta automat, dar a fost marcată deprecated de Google; în codul existent o vei mai întâlni, iar în cod nou e mai sigur să folosești direct Keystore sau o bibliotecă întreținută activ.

Alte măsuri:

  • Network Security Config: interzici traficul HTTP necriptat (implicit blocat de la Android 9) și poți configura certificate pinning, cu atenție la rotirea certificatelor, altfel blochezi aplicația la schimbarea lor;
  • R8 cu ofuscare îngreunează analiza codului, dar nu e o protecție reală pentru secrete: o cheie API pusă în aplicație poate fi extrasă. Secretele de server stau pe server;
  • android:allowBackup și regulile de backup, ca tokenurile să nu ajungă în backup-uri;
  • Play Integrity API pentru a verifica pe server că request-ul vine de la aplicația ta nemodificată;
  • fără date sensibile în log-uri, în URL-uri sau în extras de intent exportate;
  • FLAG_SECURE pe ecrane cu date sensibile, ca să blochezi capturile de ecran.

Ce urmărește intervievatorul: Se verifică maturitatea în securitate: unde stă cheia, ce nu protejează ofuscarea și ce nu se pune niciodată în aplicație.

Testare, performanță și Google Play

75 Junior

Care e diferența dintre testele din src/test și cele din src/androidTest?

Răspuns scurt: Testele din src/test sunt teste locale, rulează pe JVM-ul calculatorului, sunt rapide și potrivite pentru logică (ViewModel, use case-uri, repository-uri cu fake-uri). Cele din src/androidTest sunt teste instrumentate, rulează pe un dispozitiv sau emulator și sunt necesare pentru UI, Room real sau API-uri Android.

Un proiect Android are două seturi de surse pentru teste, cu scopuri diferite.

Teste locale (src/test):

  • rulează cu ./gradlew test, fără emulator;
  • durează milisecunde pe test;
  • nu au acces la framework-ul Android real (clasele Android din android.jar sunt doar schelete); pentru unele API-uri poți folosi Robolectric, care simulează framework-ul pe JVM;
  • testezi aici ViewModel-uri, mapări, validări, logică de business.

Teste instrumentate (src/androidTest):

  • rulează cu ./gradlew connectedAndroidTest pe un emulator sau un telefon;
  • sunt mai lente și mai fragile (animații, timp de răspuns);
  • testezi aici UI-ul cu Compose Testing sau Espresso, interogările Room pe SQLite real, migrațiile, integrarea cu sistemul.
KOTLIN
// src/test
class PriceFormatterTest {
    @Test
    fun formatsWithTwoDecimals() {
        assertEquals("12,50 lei", PriceFormatter.format(12.5))
    }
}

// src/androidTest
@RunWith(AndroidJUnit4::class)
class TaskDaoTest {
    private lateinit var db: AppDatabase
    @Before fun setup() {
        db = Room.inMemoryDatabaseBuilder(
            ApplicationProvider.getApplicationContext(), AppDatabase::class.java).build()
    }
    @After fun close() = db.close()
}

Ghidul de testare Android recomandă o piramidă: multe teste unitare locale, mai puține teste de integrare și puține teste UI end-to-end. Motivul e costul: un test UI e mai lent, mai greu de întreținut și dă un semnal mai vag când eșuează. Arhitectura contează aici: cu cât logica e mai bine scoasă din Activity-uri, cu atât mai mult poate fi testată local.

Ce urmărește intervievatorul: Se verifică dacă știi unde scrii ce fel de test și de ce. Un plus e să menționezi piramida testelor și Robolectric.

76 Junior

Cum ai scrie un test unitar pentru un ViewModel care încarcă date dintr-un repository?

Răspuns scurt: Creezi ViewModel-ul cu un repository fake, înlocuiești Dispatchers.Main cu un dispatcher de test, rulezi testul în runTest, declanșezi acțiunea și verifici starea expusă. Testezi atât cazul de succes, cât și cel de eroare.

Un test bun urmează structura Arrange, Act, Assert: pregătești datele, execuți acțiunea, verifici rezultatul. Pentru un ViewModel, „rezultatul” e starea pe care o expune.

KOTLIN
class FakeProductRepository : ProductRepository {
    var shouldFail = false
    override suspend fun getProducts(): List<Product> =
        if (shouldFail) throw IOException("offline") else listOf(Product(1, "Laptop"))
}

class MainDispatcherRule(
    val dispatcher: TestDispatcher = UnconfinedTestDispatcher()
) : TestWatcher() {
    override fun starting(description: Description) = Dispatchers.setMain(dispatcher)
    override fun finished(description: Description) = Dispatchers.resetMain()
}

class ProductsViewModelTest {
    @get:Rule val mainRule = MainDispatcherRule()
    private val repo = FakeProductRepository()

    @Test
    fun loadSuccess_showsProducts() = runTest {
        val vm = ProductsViewModel(repo)
        vm.load()
        assertEquals(UiState.Success(listOf(Product(1, "Laptop"))), vm.state.value)
    }

    @Test
    fun loadFailure_showsError() = runTest {
        repo.shouldFail = true
        val vm = ProductsViewModel(repo)
        vm.load()
        assertTrue(vm.state.value is UiState.Error)
    }
}

De ce Dispatchers.setMain: viewModelScope folosește Dispatchers.Main, care nu există pe JVM-ul de test. Fără regulă, testul aruncă excepție. Regula se scrie o dată și se refolosește în tot proiectul.

Numele testelor descriu comportamentul, nu metoda: loadFailure_showsError spune exact ce s-a stricat când eșuează. Un test verifică un singur comportament. Nu testa detalii de implementare (câte apeluri interne s-au făcut) când poți testa rezultatul vizibil; altfel testele se strică la fiecare refactorizare, deși comportamentul e același.

Ce urmărește intervievatorul: Se verifică dacă știi problema Dispatchers.Main în teste și dacă testezi și cazurile de eroare, nu doar drumul fericit.

77 Junior

Care e diferența dintre un mock și un fake? Când folosești MockK sau Mockito?

Răspuns scurt: Un fake e o implementare simplă, dar funcțională, a unei interfețe, de exemplu un repository în memorie. Un mock e generat de o bibliotecă: îl programezi ce să returneze și verifici ce apeluri a primit. Ghidul Android recomandă fake-uri.

Ambele înlocuiesc o dependență reală în teste, dar diferă ca filozofie.

Fake: o clasă scrisă de tine, cu logică simplă.

KOTLIN
class FakeUserRepository : UserRepository {
    private val users = MutableStateFlow<List<User>>(emptyList())
    override fun observeUsers(): Flow<List<User>> = users
    override suspend fun add(user: User) { users.update { it + user } }
}

Avantaje: testele verifică comportamentul real (adaugi un utilizator, apoi îl găsești în listă), fake-ul se refolosește în multe teste și nu se strică dacă schimbi implementarea internă a ViewModel-ului.

Mock cu MockK (biblioteca idiomatică pentru Kotlin, suportă funcții suspend, clase final și object):

KOTLIN
val api = mockk<PaymentApi>()
coEvery { api.charge(any()) } returns PaymentResult.Declined

val vm = CheckoutViewModel(api)
vm.pay(amount = 100)

coVerify(exactly = 1) { api.charge(100) }

Mockito funcționează și el cu Kotlin (prin mockito-kotlin); în codul nou, Mockito 5 creează implicit mock-uri pentru clase final, ceea ce înainte cerea configurare.

Când aleg mock-ul:

  • dependența e o clasă dintr-o bibliotecă, greu de implementat ca fake;
  • vreau să verific explicit că o acțiune a avut loc (s-a trimis un eveniment de analytics, s-a apelat plata o singură dată);
  • vreau să simulez rapid un caz rar, o excepție anume.

Riscul mock-urilor: teste care verifică „s-a apelat metoda X cu parametrii Y” și care se strică la orice refactorizare. Prea multe verify sunt un semn că testezi implementarea, nu comportamentul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi compromisurile și de ce testele cu prea multe mock-uri devin fragile.

78 Junior

Aplicația crapă la deschiderea unui ecran. Cum ai depana problema?

Răspuns scurt: Reproduc crash-ul, citesc stack trace-ul în Logcat și caut prima linie din codul meu și secțiunea „Caused by”. Apoi pun un breakpoint, inspectez valorile cu debugger-ul, repar cauza și adaug un test care ar fi prins problema.

Un proces calm, în pași:

1. Reproducere: pe ce dispozitiv, ce versiune de Android, ce pași? Se întâmplă mereu sau doar după rotire, doar fără internet, doar la primul start? Un crash care apare doar după revenirea din fundal e adesea legat de process death.

2. Stack trace-ul în Logcat: filtrez după pachetul aplicației și nivelul Error. Stack trace-ul arată tipul excepției, mesajul și lanțul de apeluri.

FATAL EXCEPTION: main
java.lang.IllegalStateException: Fragment ProfileFragment not attached to a context.
    at androidx.fragment.app.Fragment.requireContext(Fragment.java:...)
    at ro.exemplu.app.ProfileFragment.showName(ProfileFragment.kt:58)
    at ro.exemplu.app.ProfileFragment.access$showName(ProfileFragment.kt:22)
    ...
Caused by: ...

Citesc de sus până la prima linie din pachetul meu (aici ProfileFragment.kt:58). Dacă există „Caused by”, cauza reală e de obicei ultima din lanț.

3. Ipoteză și verificare: în exemplu, un callback ajunge după ce fragmentul s-a detașat, probabil un rezultat de rețea venit după navigare. Pun un breakpoint (sau unul condițional) în Android Studio, rulez în debug sau atașez debugger-ul la procesul care rulează, și inspectez starea și thread-ul.

4. Remediere la cauză: nu adaug un if (isAdded) ca pansament, ci leg colectarea de viewLifecycleOwner, ca rezultatul să nu mai ajungă la un fragment detașat.

5. Prevenire: un test care reproduce scenariul, dacă se poate.

Pentru crash-uri din producție, folosesc Firebase Crashlytics sau Android Vitals, care grupează crash-urile și arată dispozitivele și versiunile afectate. Pentru build-uri cu R8, stack trace-ul trebuie de-ofuscat cu fișierul mapping.txt, încărcat automat de pluginul Crashlytics sau în Play Console.

Ce urmărește intervievatorul: Se verifică metoda de depanare. Semnalul slab e să sari direct la „pun un try/catch” fără să înțelegi cauza.

79 Junior

Ce pași parcurgi ca să publici prima versiune a unei aplicații pe Google Play?

Răspuns scurt: Creezi un cont de dezvoltator Google Play, generezi un Android App Bundle (.aab) semnat în modul release, configurezi Play App Signing, completezi fișa aplicației (descriere, capturi, politica de confidențialitate, formularul Data safety, clasificarea conținutului) și publici întâi pe o pistă de testare, apoi în producție.

Pașii principali:

1. Build-ul de release: Google Play cere Android App Bundle (.aab) pentru aplicațiile noi, nu APK. Din bundle, Play generează APK-uri optimizate pentru fiecare dispozitiv (densitate, arhitectură, limbă), deci descărcarea e mai mică.

BASH
./gradlew :app:bundleRelease
# rezultatul: app/build/outputs/bundle/release/app-release.aab

2. Semnarea: creezi o upload key într-un keystore, cu care semnezi bundle-ul. Cu Play App Signing (obligatoriu pentru aplicațiile noi), Google păstrează cheia finală de semnare a aplicației. Dacă pierzi upload key, poți cere resetarea ei; dacă ai fi pierdut vechea cheie de semnare fără Play App Signing, nu ai mai fi putut actualiza aplicația. Keystore-ul și parolele nu se pun în git.

3. Configurarea în build: applicationId unic și definitiv, versionCode crescător, targetSdk la nivelul cerut de Google Play (cerința crește anual; în 2025, aplicațiile noi și actualizările trebuie să țintească API 35), minifyEnabled cu R8 testat.

4. Fișa din Play Console: nume, descrieri, iconiță, capturi de ecran, categorie, o politică de confidențialitate accesibilă printr-un URL, formularul Data safety (ce date colectezi și de ce), chestionarul de clasificare a conținutului, publicul țintă.

5. Testarea: pistele internal, closed și open testing. Conturile personale de dezvoltator create după noiembrie 2023 trebuie să ruleze un test închis cu cel puțin 12 testeri timp de 14 zile înainte de a putea publica în producție.

6. Review și lansare: aplicația trece prin verificarea Google, care poate dura de la câteva ore la câteva zile. În producție, poți folosi o lansare treptată (staged rollout) pe un procent din utilizatori.

Ce urmărește intervievatorul: Se verifică dacă ai dus o aplicație până la capăt. Mulți juniori nu știu de Play App Signing sau de cerințele de testare pentru conturile noi.

80 Mid

Cum testezi codul cu coroutines și Flow? Ce sunt runTest, StandardTestDispatcher și Turbine?

Răspuns scurt: runTest rulează testul cu timp virtual, deci delay nu așteaptă efectiv. StandardTestDispatcher ține corutinele în coadă până le avansezi explicit, UnconfinedTestDispatcher le rulează imediat, iar Turbine verifică emisiile unui Flow una câte una.

Corutinele introduc asincronie, iar testele trebuie să fie deterministe. Biblioteca kotlinx-coroutines-test oferă controlul timpului.

runTest: înlocuiește runBlocking în teste. Sare peste delay-uri folosind un ceas virtual, deci un delay(5_000) durează microsecunde. La final, verifică să nu rămână corutine neterminate.

Dispatchere de test:

  • StandardTestDispatcher: corutinele lansate nu rulează până nu cedează testul controlul (advanceUntilIdle(), runCurrent(), advanceTimeBy()). Îți dă control fin asupra ordinii.
  • UnconfinedTestDispatcher: corutinele pornesc imediat, mai simplu, dar ascunde problemele de ordine.

Dispatcherele injectate în cod (prin constructor) trebuie înlocuite cu unul de test care împarte același TestCoroutineScheduler, altfel timpul virtual nu le controlează.

Turbine (de la Cash App) face testarea flow-urilor lizibilă:

KOTLIN
@Test
fun search_debouncesAndEmitsResults() = runTest {
    val vm = SearchViewModel(FakeRepo(), dispatcher = StandardTestDispatcher(testScheduler))
    vm.results.test {
        assertEquals(emptyList<Item>(), awaitItem())   // valoarea inițială
        vm.onQueryChange("kot")
        advanceTimeBy(301)
        assertEquals(listOf(Item("Kotlin")), awaitItem())
        cancelAndIgnoreRemainingEvents()
    }
}

awaitItem() suspendă până la următoarea emisie și eșuează după un timeout dacă nu vine nimic. expectNoEvents() verifică faptul că nu s-a emis nimic.

Capcană frecventă la StateFlow cu stateIn(WhileSubscribed): dacă citești doar .value fără un colector activ, flow-ul din amonte nu pornește și valoarea rămâne cea inițială. Colectezi cu Turbine sau pornești un colector în backgroundScope.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să faci testele asincrone deterministe. Testele cu Thread.sleep sunt un semnal negativ clar.

81 Mid

Cum scrii un test de UI pentru un ecran Compose?

Răspuns scurt: Folosești createComposeRule() (sau createAndroidComposeRule pentru un Activity), setezi conținutul cu o stare cunoscută, găsești elementele cu finder-e ca onNodeWithText sau onNodeWithTag, faci acțiuni (performClick, performTextInput) și verifici rezultatul cu aserțiuni (assertIsDisplayed).

Testele Compose lucrează pe arborele semantic, aceeași informație folosită de serviciile de accesibilitate. De aceea un ecran accesibil e și ușor de testat.

KOTLIN
class LoginScreenTest {
    @get:Rule val composeRule = createComposeRule()

    @Test
    fun submitDisabled_untilEmailIsValid() {
        composeRule.setContent {
            var state by remember { mutableStateOf(LoginUiState()) }
            AppTheme {
                LoginScreen(
                    state = state,
                    onEmailChange = { state = state.copy(email = it) },
                    onSubmit = {}
                )
            }
        }

        composeRule.onNodeWithText("Intră în cont").assertIsNotEnabled()
        composeRule.onNodeWithTag("email").performTextInput("ana@exemplu.ro")
        composeRule.onNodeWithText("Intră în cont").assertIsEnabled()
    }

    @Test
    fun error_isShown() {
        composeRule.setContent { LoginScreen(LoginUiState(error = "Parolă greșită"), {}, {}) }
        composeRule.onNodeWithText("Parolă greșită").assertIsDisplayed()
    }
}

Modifier.testTag("email") marchează elementele greu de găsit după text. Ca regulă, caută elementele cum le-ar găsi utilizatorul, după text sau contentDescription, și folosește tag-uri doar unde nu există altă cale.

De ce funcționează simplu: pentru că ecranul e stateless (primește starea și callback-uri), îl testezi cu orice stare, fără ViewModel și fără rețea. Pentru un flux complet, cu Hilt, folosești @HiltAndroidTest și înlocuiești modulele reale cu fake-uri.

Compose sincronizează automat testul cu recompunerile și animațiile, deci nu ai nevoie de pauze. Pentru operații asincrone externe există waitUntil { }. Testele rulează implicit ca instrumentate, pe emulator; cu Robolectric pot rula și local, pe JVM. Pentru ecranele cu View-uri, echivalentul este Espresso (onView(withId(...)).perform(click())). Pentru verificarea aspectului vizual se folosesc screenshot tests.

Ce urmărește intervievatorul: Se verifică dacă ai scris teste UI și dacă înțelegi legătura dintre arborele semantic, accesibilitate și testabilitate.

82 Mid

Ce face R8 și ce probleme pot apărea când activezi minifyEnabled în build-ul de release?

Răspuns scurt: R8 este compilatorul Android care micșorează codul (elimină clasele și metodele nefolosite), îl optimizează și îl ofuscă, redenumind clasele. Problemele apar la codul accesat prin reflexie (serializare, unele biblioteci), pe care R8 îl poate elimina sau redenumi, și se rezolvă cu reguli -keep în proguard-rules.pro.

R8 a înlocuit ProGuard în pipeline-ul Android și folosește același format de reguli. Activarea se face în configurarea de release:

KOTLIN
android {
    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

Ce face:

  • shrinking: pornind de la punctele de intrare (componentele din manifest), urmărește ce cod e folosit și elimină restul, inclusiv din biblioteci;
  • optimizare: inlining, eliminarea codului mort, simplificări;
  • ofuscare: redenumește clasele și metodele în nume scurte (a, b), ceea ce micșorează aplicația;
  • isShrinkResources elimină și resursele nefolosite.

Problemele tipice:

  • codul folosit doar prin reflexie pare nefolosit: Gson care completează câmpuri după nume, clase instanțiate după numele lor din string-uri. Rezultatul: câmpuri null în release, deși în debug totul merge;
  • excepții ClassNotFoundException sau NoSuchMethodException doar în release;
  • stack trace-uri ofuscate în rapoartele de crash.

Soluții:

-keep class ro.exemplu.app.data.dto.** { *; }
-keepattributes Signature, *Annotation*

Majoritatea bibliotecilor moderne (kotlinx.serialization, Retrofit, Room, Moshi cu codegen) includ propriile reguli în AAR, aplicate automat. Problemele apar mai ales cu cod vechi sau reflexie proprie.

Bune practici: testezi build-ul de release înainte de publicare, nu doar debug; păstrezi fișierul mapping.txt pentru fiecare versiune (Play Console îl poate primi automat) ca să de-ofuști crash-urile; scrii reguli -keep cât mai înguste, pentru că un -keep class ** anulează beneficiile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai trecut printr-un bug care apare doar în release. Un plus e să știi de fișierul mapping.txt.

83 Mid

Ce înseamnă versionCode, versionName, minSdk, targetSdk și compileSdk?

Răspuns scurt: versionCode e un întreg care crește la fiecare versiune publicată, versionName e eticheta afișată. minSdk e cea mai veche versiune suportată, compileSdk versiunea API cu care compilezi, iar targetSdk versiunea ale cărei comportamente le activezi.

Toate se setează în build.gradle.kts al modulului aplicației:

KOTLIN
android {
    compileSdk = 35
    defaultConfig {
        applicationId = "ro.exemplu.app"
        minSdk = 24
        targetSdk = 35
        versionCode = 42
        versionName = "2.3.1"
    }
}

versionCode: Google Play îl folosește ca să decidă ce versiune e mai nouă. Nu poți urca un bundle cu versionCode egal sau mai mic decât unul deja încărcat. Multe echipe îl generează automat în CI (de exemplu din numărul build-ului).

versionName: pur informativ pentru utilizatori, de obicei versionare semantică (major.minor.patch).

minSdk: sub această versiune aplicația nu se poate instala. O valoare mai mică înseamnă mai mulți utilizatori, dar și mai multe verificări de versiune în cod (if (Build.VERSION.SDK_INT >= ...)). Bibliotecile Jetpack își cresc și ele periodic minSdk-ul minim.

compileSdk: determină ce API-uri poți folosi în cod. Nu schimbă comportamentul la rulare. De obicei e cea mai nouă versiune stabilă.

targetSdk: aici e cea mai importantă subtilitate. Android activează schimbările de comportament ale unei versiuni noi doar pentru aplicațiile care o țintesc. De exemplu, restricțiile pentru foreground services din Android 14 se aplică aplicațiilor cu targetSdk 34 sau mai mare. Când crești targetSdk, trebuie să citești lista de schimbări de comportament ale versiunii și să testezi. Google Play impune un targetSdk minim care crește anual, deci această actualizare e o sarcină recurentă.

Regula: minSdk mai mic sau egal cu targetSdk, care la rândul lui e mai mic sau egal cu compileSdk.

Ce urmărește intervievatorul: Se verifică distincția dintre compileSdk și targetSdk, pe care mulți candidați o confundă.

84 Senior

Ce faci dacă după lansarea unei versiuni noi crește brusc rata de crash-uri?

Răspuns scurt: Opresc lansarea treptată din Play Console, ca versiunea să nu mai ajungă la alți utilizatori, analizez crash-urile în Crashlytics sau Android Vitals, lansez treptat un hotfix cu versionCode mai mare și apoi discut cu echipa cum prevenim situația.

Pregătirea face diferența. Dacă versiunea a fost lansată cu staged rollout (de exemplu 5%, apoi 20%, apoi 100%), doar o parte din utilizatori sunt afectați.

1. Limitarea impactului: în Play Console oprești lansarea. Utilizatorii care au actualizat deja rămân pe versiunea nouă, pentru că pe Google Play nu poți retrograda aplicația. Dacă problema vine dintr-o funcționalitate nouă protejată de un feature flag (de exemplu prin Firebase Remote Config), o dezactivezi de la distanță în câteva minute, fără o nouă versiune.

2. Diagnosticul: Crashlytics grupează crash-urile după cauză și arată ce versiuni, dispozitive și versiuni de Android sunt afectate. Întrebările-cheie: crash-ul e nou în această versiune? Apare doar pe o versiune de Android sau la un producător anume? Are legătură cu o migrare de bază de date sau cu un câmp nou din API?

3. Remedierea: un hotfix mic, doar pentru cauză, revizuit și testat, inclusiv pe scenariul de actualizare de la versiunea veche (migrațiile Room sunt o sursă frecventă). Primește un versionCode nou și trece din nou prin review. Lansarea se face tot treptat.

4. Comunicarea: anunț echipa și pe product owner ce se întâmplă, ce impact are și cât estimez până la remediere.

5. Post-mortem fără vinovați: ce test ar fi prins problema? Avem nevoie de testare pe mai multe dispozitive, de o perioadă mai lungă pe pista beta sau de praguri automate de oprire?

Android Vitals urmărește pragurile de calitate pentru crash-uri și ANR-uri, iar depășirea lor poate reduce vizibilitatea aplicației în magazin. De aceea monitorizarea după lansare face parte din proces.

Ce urmărește intervievatorul: La senior se verifică reacția în incident: limitarea impactului, comunicarea și prevenția. Un plus e să știi că nu poți face rollback pe Google Play.

85 Senior

Cum ai îmbunătăți timpul de pornire al unei aplicații Android?

Răspuns scurt: Măsor întâi timpul de pornire la rece cu Macrobenchmark, apoi elimin munca din Application.onCreate și din primul ecran (inițializări leneșe, lucru mutat pe fundal), generez Baseline Profiles ca codul critic să fie precompilat și verific rezultatul cu aceleași măsurători.

Primul pas e măsurarea. Pornirea la rece (cold start, procesul nu există) e cazul cel mai lent și cel mai relevant. Android Vitals raportează startup-ul lent, iar local îl măsori cu Macrobenchmark:

KOTLIN
@RunWith(AndroidJUnit4::class)
class StartupBenchmark {
    @get:Rule val rule = MacrobenchmarkRule()

    @Test
    fun coldStartup() = rule.measureRepeated(
        packageName = "ro.exemplu.app",
        metrics = listOf(StartupTimingMetric()),
        iterations = 10,
        startupMode = StartupMode.COLD
    ) {
        pressHome()
        startActivityAndWait()
    }
}

Rezultatul îți dă timeToInitialDisplay și, dacă apelezi reportFullyDrawn() când datele sunt afișate, timeToFullDisplay.

Ce optimizez apoi:

  • Application.onCreate: aici ajung inițializările tuturor bibliotecilor. Le fac leneșe (la prima utilizare), le mut pe un thread de fundal dacă nu sunt necesare imediat sau le inițializez cu App Startup. Un SDK de analytics nu trebuie să blocheze primul cadru;
  • injectarea de dependențe: graful Hilt creat la pornire nu ar trebui să construiască obiecte scumpe (baza de date, clientul HTTP) până nu sunt necesare; Lazy<T> sau Provider<T> ajută;
  • primul ecran: evit I/O sincron, afișez un schelet al ecranului și încarc datele asincron; folosesc Splash Screen API (Android 12+) corect, fără să țin ecranul de splash mai mult decât e nevoie;
  • Baseline Profiles: o listă de clase și metode folosite la pornire, generată cu biblioteca Baseline Profile Gradle Plugin. Google Play și ART le compilează ahead-of-time la instalare, deci codul nu mai e interpretat sau compilat JIT la primele rulări. Compose beneficiază mult, fiind o bibliotecă inclusă în aplicație.

Măsoară întotdeauna pe build-ul de release, cu R8 activ; măsurătorile pe debug nu sunt relevante.

Ce urmărește intervievatorul: Se verifică abordarea bazată pe măsurători. Răspunsul slab enumeră optimizări fără să spună cum știi că au ajutat.

Gradle, Git și Scrum

86 Junior

Cum este organizat build-ul unui proiect Android cu Gradle și ce este un version catalog?

Răspuns scurt: Proiectul are un settings.gradle.kts care declară modulele, un build.gradle.kts la rădăcină și câte unul pentru fiecare modul, cu pluginuri, configurarea android { } și dependențe. Version catalog-ul (gradle/libs.versions.toml) centralizează versiunile bibliotecilor și pluginurilor, ca să fie aceleași în toate modulele.

Fișierele principale:

  • settings.gradle.kts: repository-urile de unde se descarcă pluginurile și bibliotecile (google(), mavenCentral()) și lista de module (include(":app", ":core:data"));
  • build.gradle.kts la rădăcină: declară pluginurile folosite în proiect, de obicei cu apply false;
  • app/build.gradle.kts: pluginurile modulului, blocul android { } (namespace, SDK-uri, build types) și dependențele;
  • gradle.properties: setări ca memoria pentru Gradle sau android.useAndroidX=true;
  • gradle/wrapper: versiunea fixă de Gradle, rulată prin ./gradlew, ca toată echipa și CI-ul să folosească aceeași.

Version catalog, formatul standard în proiectele create cu Android Studio recent:

TOML
[versions]
kotlin = "2.0.21"
room = "2.6.1"

[libraries]
room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }

[plugins]
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
ksp = { id = "com.google.devtools.ksp", version = "2.0.21-1.0.27" }
KOTLIN
plugins {
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.ksp)
}
dependencies {
    implementation(libs.room.runtime)
    ksp(libs.room.compiler)
}

Configurațiile de dependențe pe care trebuie să le știi: implementation (vizibilă doar în modul), api (expusă și modulelor care depind de el), testImplementation, androidTestImplementation, debugImplementation, plus ksp pentru procesoare de adnotări.

Pentru biblioteci Compose se folosește un BOM (platform(libs.compose.bom)), care fixează versiuni compatibile între ele, deci nu mai scrii versiunea la fiecare bibliotecă.

Ce urmărește intervievatorul: Se verifică dacă te descurci cu configurarea proiectului. Mulți juniori nu știu diferența dintre implementation și api.

87 Junior

Ce sunt build types și product flavors și când le folosești?

Răspuns scurt: Build types (debug, release) descriu cum e construită aplicația: semnare, optimizări, depanare. Product flavors (de exemplu free și paid, sau dev și prod) descriu variante diferite ale produsului. Combinația lor formează build variants, de exemplu devDebug sau prodRelease.

Build types există implicit: debug, semnat automat cu cheia de debug și cu depanare activă, și release, cu R8 și semnătura reală. Poți adăuga altele, de exemplu benchmark.

Product flavors creează versiuni diferite ale aplicației din același cod: un mediu de test și unul de producție, o variantă gratuită și una plătită, aplicații pentru clienți diferiți (white-label).

KOTLIN
android {
    buildFeatures { buildConfig = true }

    buildTypes {
        debug {
            applicationIdSuffix = ".debug"
        }
        release {
            isMinifyEnabled = true
            signingConfig = signingConfigs.getByName("release")
        }
    }

    flavorDimensions += "env"
    productFlavors {
        create("dev") {
            dimension = "env"
            applicationIdSuffix = ".dev"
            buildConfigField("String", "API_URL", "\"https://api-dev.exemplu.ro/\"")
        }
        create("prod") {
            dimension = "env"
            buildConfigField("String", "API_URL", "\"https://api.exemplu.ro/\"")
        }
    }
}

În cod citești BuildConfig.API_URL. Cu applicationIdSuffix, versiunea de dezvoltare și cea de producție pot fi instalate simultan pe același telefon.

Fiecare variantă poate avea surse și resurse proprii: src/dev/, src/prod/, src/debug/. De exemplu, în src/debug poți pune un ecran de setări pentru testeri, care nu ajunge niciodată în release. Dependențele pot fi și ele specifice: debugImplementation(libs.leakcanary).

Atenție la explozia combinațiilor: 2 build types × 3 flavors × 2 dimensiuni înseamnă zeci de variante și un build mai lent de configurat. Pentru simple comutatoare de funcționalități, un feature flag configurat de la distanță e adesea mai potrivit decât un flavor nou.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să separi mediile dev/prod fără să schimbi codul manual înainte de fiecare build.

88 Junior

Care e diferența dintre git merge și git rebase?

Răspuns scurt: Ambele integrează schimbările dintr-o ramură în alta. merge păstrează istoricul și creează un commit de merge; rebase rescrie commit-urile tale peste vârful celeilalte ramuri, cu istoric liniar. Nu faci rebase pe o ramură folosită și de alții.

Să zicem că ai creat ramura feature/login din main, ai făcut trei commit-uri, iar între timp colegii au adăugat două commit-uri pe main.

Merge:

BASH
git switch feature/login
git merge main

Git creează un commit nou, cu doi părinți, care unește cele două istorii. Nimic existent nu se modifică. Istoricul arată exact ce s-a întâmplat, dar cu multe ramuri devine greu de citit.

Rebase:

BASH
git switch feature/login
git fetch origin
git rebase origin/main

Git ia commit-urile tale, le „scoate” și le aplică din nou, unul câte unul, peste ultimul commit din main. Rezultatul e un istoric liniar, ca și cum ai fi început lucrul abia acum. Commit-urile tale primesc hash-uri noi.

Consecința importantă: dacă ai urcat deja ramura și altcineva lucrează pe ea, după rebase istoria ta diferă de a lor. Ai nevoie de git push --force-with-lease (mai sigur decât --force, pentru că refuză suprascrierea dacă între timp a urcat altcineva ceva), iar colegii vor avea conflicte. Regula: rebase pe ramurile tale locale sau personale, merge pe ramurile comune.

La conflicte, rebase te oprește la fiecare commit în parte: rezolvi, git add, apoi git rebase --continue (sau --abort ca să revii la starea de dinainte).

Multe echipe folosesc „squash and merge” la pull request-uri, care adună toate commit-urile ramurii într-unul singur pe main. La interviu, contează mai puțin ce preferi și mai mult să înțelegi consecințele fiecărei opțiuni.

Ce urmărește intervievatorul: Se verifică înțelegerea rescrierii istoricului și a riscurilor. Greșeala tipică e un rebase urmat de push --force pe o ramură comună.

89 Junior

Descrie fluxul tău de lucru cu Git într-o echipă, de la un task nou până la merge, inclusiv rezolvarea unui conflict.

Răspuns scurt: Pornesc o ramură din main-ul actualizat, fac commit-uri mici, deschid un pull request, răspund la review și fac merge după ce trece CI-ul. La un conflict, înțeleg ambele schimbări, combin intenția lor și verific build-ul și testele.

Un flux tipic, apropiat de GitHub Flow:

BASH
git switch main
git pull
git switch -c feature/AP-123-cart-discount

# lucru, apoi
git add -p                      # aleg ce bucăți intră în commit
git commit -m "Aplică reducerea din cupon la totalul coșului"
git push -u origin feature/AP-123-cart-discount

Reguli bune:

  • commit-uri mici, cu un singur scop: un reviewer înțelege mai ușor zece commit-uri clare decât unul uriaș, iar git bisect și revert devin utile;
  • mesajul spune ce și de ce, nu „fix” sau „modificări”;
  • nu urci fișiere generate (build/), chei sau local.properties; de asta există .gitignore;
  • ramura trăiește puțin; cu cât stă mai mult separată, cu atât conflictele sunt mai mari.

Pull request-ul: descriere scurtă (ce, de ce, cum se testează, capturi de ecran pentru UI), CI-ul rulează build-ul, testele și lint-ul, iar colegii comentează.

Un conflict apare când tu și altcineva ați modificat aceleași linii:

<<<<<<< HEAD
val total = subtotal - discount
=======
val total = (subtotal - discount).coerceAtLeast(0.0)
>>>>>>> origin/main

Nu aleg orbește „versiunea mea”. Citesc ce a vrut să rezolve fiecare schimbare (istoricul și PR-ul colegului ajută) și combin intenția: aici, reducerea plus protecția împotriva valorilor negative. Apoi elimin marcajele, rulez build-ul și testele, git add și continui merge-ul sau rebase-ul. Fișierele generate sau de tip lock (cum e schema Room exportată) se regenerează, nu se editează manual. Dacă nu înțeleg schimbarea colegului, îl întreb înainte să rezolv.

Ce urmărește intervievatorul: Intervievatorul verifică obiceiurile de lucru în echipă. Un plus e să spui că verifici build-ul și testele după rezolvarea conflictului.

90 Junior

Cum funcționează Scrum: ce roluri, evenimente și artefacte există?

Răspuns scurt: Scrum organizează lucrul în sprinturi de lungime fixă, de obicei una până la patru săptămâni. Are trei roluri (Product Owner, Scrum Master, Developers), cinci evenimente (Sprint, Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective) și trei artefacte (Product Backlog, Sprint Backlog, Increment).

Scrum e un cadru pentru dezvoltare iterativă: în loc să planifici totul de la început, livrezi un increment funcțional la fiecare sprint și ajustezi pe baza feedback-ului.

Roluri (Scrum Guide le numește responsabilități):

  • Product Owner: decide ce se construiește și în ce ordine; gestionează Product Backlog-ul și maximizează valoarea produsului;
  • Scrum Master: ajută echipa să aplice Scrum, elimină obstacolele, facilitează evenimentele. Nu e șeful echipei;
  • Developers: toți cei care construiesc incrementul: dezvoltatori Android, iOS, backend, QA, designeri.

Evenimente:

  • Sprint Planning: echipa alege din backlog ce poate livra în sprint și stabilește obiectivul sprintului;
  • Daily Scrum: maximum 15 minute pe zi, pentru sincronizare față de obiectivul sprintului și pentru a semnala blocajele. Nu e un raport de stare către manager;
  • Sprint Review: echipa arată ce a construit, iar stakeholderii dau feedback; pe mobil, de obicei o demonstrație pe telefon;
  • Sprint Retrospective: echipa discută cum a lucrat și alege una sau două îmbunătățiri concrete.

Artefacte:

  • Product Backlog: lista ordonată a tot ce ar putea intra în produs;
  • Sprint Backlog: elementele alese pentru sprint plus planul de livrare;
  • Increment: suma lucrului terminat, care respectă Definition of Done.

Particularitate pe Android: „terminat” într-un sprint nu înseamnă automat „ajuns la utilizatori”, pentru că publicarea trece prin review-ul Google Play și prin lansări treptate. Multe echipe au un ritm de release separat de sprint (de exemplu o versiune la două săptămâni) și folosesc feature flags ca să integreze cod neterminat fără să-l expună.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat într-o echipă Agile și dacă înțelegi scopul evenimentelor, nu doar numele lor.

91 Mid

Cum estimezi un task și ce înseamnă Definition of Done într-o echipă de mobile?

Răspuns scurt: Estimez relativ, în story points, comparând task-ul cu altele deja făcute și ținând cont de complexitate și incertitudine. Definition of Done e lista comună de condiții pentru „gata”: cod revizuit, teste, verificare pe dispozitive, fără regresii.

Estimarea: oamenii estimează prost în ore absolute, dar destul de bine relativ („asta e cam de două ori mai greu decât ecranul de login”). Story points exprimă efortul relativ, de obicei pe o scară Fibonacci (1, 2, 3, 5, 8, 13), care reflectă faptul că incertitudinea crește cu mărimea.

În planning poker, fiecare membru alege o estimare în același timp. Dacă cineva spune 2 și altcineva 8, discuția e valoroasă: unul știe probabil ceva ce celălalt nu știe (o bibliotecă ce trebuie actualizată, un caz special pe tablete).

Ce iau în calcul pentru un task Android:

  • UI-ul pentru toate stările (încărcare, gol, eroare, offline);
  • mărimi de ecran, mod întunecat, accesibilitate;
  • dependența de API-ul de backend, care poate să nu fie gata;
  • testele și migrațiile de bază de date;
  • permisiuni și diferențele dintre versiunile de Android.

Un task estimat la 13 e de obicei prea mare sau prea neclar; îl împart sau propun un spike limitat în timp, pentru investigație.

Definition of Done e un acord al echipei. Un exemplu pentru o echipă mobile:

- codul e revizuit și aprobat de cel puțin un coleg
- build-ul CI trece: compilare, teste unitare, lint
- testele noi acoperă logica principală
- testat pe un telefon cu Android vechi (minSdk) și pe unul recent
- verificat în mod întunecat și cu font mărit
- textele sunt în fișierele de resurse și traduse
- Product Owner-ul a acceptat funcționalitatea

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi estimarea ca instrument de discuție, nu ca promisiune, și ce înseamnă „gata” pe mobil.

92 Mid

Ai făcut din greșeală un commit greșit. Care e diferența dintre git revert, git reset și git cherry-pick?

Răspuns scurt: git revert creează un commit nou care anulează un commit existent, fără să rescrie istoricul, deci e sigur pe ramuri comune. git reset mută ramura înapoi, rescriind istoricul local. git cherry-pick copiază un commit anume pe ramura curentă.

Alegerea depinde de un lucru: commit-ul a fost deja urcat și folosit de alții?

git revert <hash>: adaugă un commit care face exact opusul. Istoricul rămâne intact, deci e soluția potrivită pentru main sau orice ramură comună.

BASH
git revert a1b2c3d
git push

git reset: mută pointerul ramurii la alt commit. Are trei moduri:

  • --soft: commit-urile dispar, dar schimbările rămân pregătite pentru commit (staged);
  • --mixed (implicit): schimbările rămân în fișiere, dar nu mai sunt staged;
  • --hard: schimbările sunt șterse din fișiere. Periculos, dar poți recupera de obicei commit-urile cu git reflog pentru o perioadă.
BASH
git reset --soft HEAD~1    # „desfac” ultimul commit, păstrez modificările

Folosești reset doar pe commit-uri locale, neurcate. Pentru un mesaj greșit în ultimul commit, git commit --amend e mai simplu.

git cherry-pick <hash>: copiază un commit pe ramura curentă, cu hash nou. Scenariul clasic pe mobil: o eroare critică a fost reparată pe develop, dar versiunea din magazin vine din release/2.3.

BASH
git switch release/2.3
git cherry-pick f4e5d6c
# crești versionCode, construiești bundle-ul, îl urci pe Play

Cherry-pick-ul frecvent e un semn că ramurile au divergat prea mult; dacă e posibil, repari pe ramura de release și faci merge înapoi în develop, ca fixul să nu se piardă.

Ca regulă de siguranță, înainte de orice comandă care rescrie istoricul, creezi o ramură de rezervă (git branch backup-inainte-de-reset).

Ce urmărește intervievatorul: Se verifică dacă știi ce comenzi sunt sigure pe ramuri comune. reset --hard urmat de push --force pe main e semnalul de alarmă.

93 Senior

Cum ai configura un pipeline CI/CD pentru o aplicație Android?

Răspuns scurt: La fiecare pull request, CI-ul rulează build-ul, lint-ul și testele. La un tag de release, construiește bundle-ul semnat cu chei păstrate ca secrete și îl urcă automat pe o pistă de testare din Google Play.

Scopul e ca nimic să nu ajungă în main sau la utilizatori fără verificări automate și ca publicarea să nu depindă de laptopul unui coleg.

O variantă cu GitHub Actions:

YAML
name: android
on:
  pull_request:
  push:
    tags: ["v*"]

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { distribution: temurin, java-version: "17" }
      - uses: gradle/actions/setup-gradle@v4
      - run: ./gradlew lint testDebugUnitTest assembleDebug

  release:
    if: startsWith(github.ref, 'refs/tags/v')
    needs: check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { distribution: temurin, java-version: "17" }
      - run: echo "$KEYSTORE_B64" | base64 -d > upload.jks
        env: { KEYSTORE_B64: "${{ secrets.UPLOAD_KEYSTORE }}" }
      - run: ./gradlew bundleRelease
        env:
          KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}

Decizii importante:

  • secretele (keystore-ul de upload, parolele, contul de serviciu pentru Play) stau în managerul de secrete al CI-ului, nu în repository. Configurarea de semnare din Gradle le citește din variabile de mediu;
  • cache-ul Gradle și build cache-ul reduc mult timpul de rulare;
  • versionCode se generează automat, de exemplu din numărul rulării, ca să nu apară conflicte;
  • testele instrumentate pe emulator sunt lente și instabile pe mașinile CI; multe echipe le rulează noaptea sau doar pentru modulele critice, ori folosesc Gradle Managed Devices sau Firebase Test Lab;
  • publicarea: pluginul Gradle Play Publisher sau Fastlane urcă bundle-ul pe pista internă, iar promovarea în producție rămâne o decizie umană;
  • fișierul mapping.txt se păstrează ca artefact pentru fiecare release.

Un pipeline bun e rapid la PR-uri: dacă durează 40 de minute, oamenii încep să-l ocolească.

Ce urmărește intervievatorul: La senior se verifică experiența cu automatizarea livrării și cu gestionarea secretelor de semnare.

Comportamentale și HR

94 Junior

De ce vrei să lucrezi ca Android Developer?

Răspuns scurt: Un răspuns bun leagă un motiv personal concret (ce te atrage la aplicațiile mobile) de ce ai făcut deja pentru asta (proiecte, cursuri) și de ce cauți în rolul următor. Evită răspunsurile generice despre salarii sau „e la modă”.

Intervievatorul vrea să știe dacă alegerea e gândită și dacă vei rămâne motivat când apar părțile mai puțin plăcute ale meseriei: fragmentarea dispozitivelor, review-urile din Google Play, bug-uri care apar doar pe un model de telefon.

O structură simplă, în trei părți:

  • Ce te atrage concret: de exemplu faptul că o aplicație ajunge în buzunarul oamenilor și o folosesc zilnic, că vezi imediat rezultatul muncii tale pe ecran, combinația dintre logică și design, ecosistemul Kotlin și Jetpack Compose.
  • Ce ai făcut deja: un proiect personal publicat sau pe GitHub, un curs, o aplicație făcută pentru cineva cunoscut. Dovezile valorează mai mult decât entuziasmul declarat.
  • Ce cauți acum: să lucrezi într-o echipă cu code review, să înveți arhitectură pe o aplicație reală, să ajungi la un nivel anume.

Exemplu de răspuns:

„Am început cu Kotlin pentru că voiam să fac o aplicație pentru antrenamentele mele la sală. Partea care m-a prins a fost să văd pe telefon ceva construit de mine și să o îmbunătățesc după ce o foloseam câteva zile. Am refăcut-o apoi cu Compose, Room și MVVM și am urcat-o pe un test închis în Google Play. Acum vreau să lucrez într-o echipă în care să primesc feedback în code review și să învăț cum arată o aplicație mare, cu module și teste.”

Ce să eviți: „orice job în IT e bun”, critici la adresa jobului actual, un răspuns învățat pe de rost care nu are legătură cu tine. Dacă vii din altă meserie, spune deschis și arată ce aduci în plus din experiența anterioară.

Ce urmărește intervievatorul: Se verifică motivația și dacă aceasta e susținută de fapte. Răspunsul generic, fără niciun proiect concret, e cel mai slab.

95 Junior

Prezintă un proiect Android pe care l-ai construit. Ce decizii tehnice ai luat și ce ai face altfel acum?

Răspuns scurt: Alege un proiect pe care îl cunoști în detaliu, descrie în două propoziții problema rezolvată, apoi explică două-trei decizii tehnice cu motivul lor (arhitectură, biblioteci, stocare) și încheie cu o lecție concretă despre ce ai schimba.

E probabil cea mai importantă întrebare pentru un junior, pentru că din ea vin multe întrebări tehnice de follow-up. Pregătește-o înainte și ai proiectul deschis, pe telefon sau pe GitHub.

Structura care funcționează:

  • Contextul (2–3 propoziții): ce face aplicația, pentru cine, ce problemă rezolvă.
  • Arhitectura pe scurt: „Compose pentru UI, un ViewModel per ecran cu StateFlow, repository care combină Retrofit și Room, Hilt pentru dependențe.”
  • Două sau trei decizii cu motivul lor: „Am făcut baza de date sursa unică de adevăr, ca aplicația să meargă și fără internet, pentru că o foloseam la sală, unde semnalul e slab.” Sau: „Am ales DataStore în loc de SharedPreferences pentru că API-ul e asincron.”
  • O problemă reală pe care ai rezolvat-o: un bug, o limitare de performanță, o migrare de bază de date.
  • Ce ai face altfel: „Aș scrie testele pentru ViewModel de la început. Le-am adăugat la final și am descoperit că logica era prea legată de UI ca să o testez ușor, așa că a trebuit să refactorizez.”

Partea finală contează mult: arată că poți să-ți evaluezi critic propriul cod, ceea ce e mai valoros decât un proiect perfect.

Ce să eviți:

  • să enumeri biblioteci fără să poți explica de ce le-ai folosit;
  • să prezinți ca fiind al tău cod copiat dintr-un tutorial; vei primi întrebări de detaliu și se va vedea;
  • să intri în detalii minore înainte să fi dat imaginea de ansamblu.

Dacă proiectul a fost făcut în echipă, spune clar care a fost partea ta.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi codul pe care l-ai scris și dacă reflectezi critic. Follow-up-urile tehnice pornesc de aici.

96 Junior

Ce faci când primești un task și nu știi cum să-l rezolvi?

Răspuns scurt: Clarific întâi cerința, apoi investighez singur un timp limitat: documentația oficială, codul existent din proiect, căutări țintite. Dacă tot sunt blocat, cer ajutor cu o întrebare clară, în care arăt ce am încercat deja.

Întrebarea verifică două riscuri pe care le are orice junior: că va sta blocat în tăcere sau că va întreba la fiecare pas fără să încerce singur.

Un model de răspuns:

  • Înțeleg problema: recitesc task-ul, verific criteriile de acceptare, întreb Product Owner-ul sau colegul care l-a scris dacă e ceva neclar. Multe blocaje vin dintr-o cerință înțeleasă greșit.
  • Caut în proiect: aproape orice aplicație are deja un ecran asemănător, un repository sau un pattern pe care îl pot urma. Așa respect și convențiile echipei.
  • Documentația oficială: developer.android.com, documentația Kotlin și a bibliotecilor. Pentru erori, mesajul exact al excepției. Când folosesc un asistent AI, verific și înțeleg codul înainte să-l pun în proiect.
  • Îmi stabilesc o limită de timp: de exemplu o oră sau două pentru o problemă blocantă. După ea, cer ajutor.
  • Întreb bine: „Încerc să afișez lista din Room în Compose, dar nu se actualizează după inserare. Am verificat că DAO-ul returnează Flow și că inserarea are loc. Bănuiesc că ViewModel-ul colectează o singură dată. Poți să te uiți 10 minute?”

O astfel de întrebare îi ia colegului puțin timp și arată că ai lucrat. După ce primești răspunsul, notează ce ai învățat, ca să nu întrebi de două ori același lucru.

Dacă ai un exemplu real, povestește-l scurt: „La proiectul X nu știam cum să fac paginarea. Am citit ghidul Paging 3, am încercat un prototip mic separat de aplicație și apoi l-am integrat.” Un exemplu concret valorează mai mult decât descrierea teoretică a procesului.

Ce urmărește intervievatorul: Se verifică autonomia și comunicarea. Răspunsurile extreme („mă descurc mereu singur” sau „întreb imediat”) sunt semnale negative.

97 Mid

Povestește despre cel mai greu bug pe care l-ai rezolvat într-o aplicație.

Răspuns scurt: Folosește structura STAR: situația (ce se întâmpla și cât de grav era), sarcina ta, acțiunile concrete prin care ai găsit cauza (reproducere, log-uri, ipoteze eliminate) și rezultatul, inclusiv ce ai schimbat ca să nu se mai repete.

Intervievatorul nu caută cel mai spectaculos bug, ci felul în care gândești când lucrurile nu merg. Structura STAR te ajută să nu te pierzi în detalii:

  • Situația: „Utilizatorii raportau că lista de comenzi apărea uneori goală după ce reveneau în aplicație. Nu reușeam să reproducem problema pe telefoanele noastre.”
  • Sarcina: „Eram responsabil de modulul de comenzi, așa că am preluat investigația.”
  • Acțiunile, partea cea mai importantă: „Am observat în Crashlytics că problemele apăreau mai ales pe telefoane cu memorie puțină. Am bănuit process death și l-am simulat cu adb shell am kill în timp ce aplicația era în fundal. Am reprodus problema imediat. Cauza: ID-ul clientului era ținut într-un singleton, care după recrearea procesului era null, iar interogarea returna o listă goală, fără nicio eroare. L-am mutat în SavedStateHandle, primit din argumentele de navigare.”
  • Rezultatul: „Problema a dispărut din rapoarte în versiunea următoare. Am adăugat în checklist-ul de testare scenariul de process death și am prezentat echipei cum se simulează.”

Ce face un răspuns bun:

  • arată un proces: reproducere, ipoteze, eliminarea lor, confirmare;
  • folosește unelte concrete (Logcat, debugger, profiler, Crashlytics, git bisect);
  • spune ce ai învățat și ce s-a schimbat în proces, nu doar în cod;
  • e sincer în privința greșelilor, inclusiv ale tale.

Ce să eviți: un bug banal („am uitat o virgulă”), o poveste în care altcineva a găsit soluția, detalii tehnice atât de multe încât nu se mai înțelege firul. Pregătește două povești, pentru că uneori urmează întrebarea „mai ai un exemplu?”.

Ce urmărește intervievatorul: Se verifică metoda de depanare și onestitatea. Un plus mare e partea de prevenție de la final.

98 Mid

Cum reacționezi când un coleg îți respinge abordarea în code review sau nu ești de acord cu o decizie tehnică?

Răspuns scurt: Încerc întâi să înțeleg argumentul celuilalt, apoi îmi prezint argumentele cu fapte (documentație, măsurători, un exemplu), nu cu preferințe. Dacă nu ajungem la acord, implicăm pe cineva cu mai mult context, iar decizia finală o susțin.

Code review-ul e locul unde apar cele mai multe dezacorduri tehnice. Intervievatorul vrea să vadă că poți colabora fără să iei comentariile personal și fără să cedezi orice doar ca să eviți discuția.

Un model de răspuns, cu un exemplu:

„Într-un PR am folosit SharedFlow pentru evenimentele de navigare, iar un coleg mai experimentat a cerut să le modelez ca stare. Prima reacție a fost să-mi apăr soluția, pentru că funcționa. Am întrebat de ce preferă varianta lui și mi-a arătat că evenimentul se poate pierde dacă e emis în timpul unei rotiri. Am verificat în ghidul de arhitectură Android, am reprodus situația și am schimbat implementarea. Am învățat un lucru pe care nu-l știam.”

Și varianta în care ai dreptate:

„Altă dată, colegul voia să adăugăm o bibliotecă nouă pentru o problemă mică. Am explicat că ar crește dimensiunea aplicației și că putem rezolva cu 30 de linii de cod și un test. Am făcut un prototip mic ca să vadă diferența, iar echipa a ales varianta fără bibliotecă.”

Principii:

  • separă persoana de cod: comentariul e despre soluție, nu despre tine;
  • întreabă „ce risc vezi?” înainte să răspunzi;
  • adu argumente verificabile: documentație, măsurători, un test;
  • discuțiile lungi le muți din comentarii într-un apel scurt;
  • „disagree and commit”: după decizie, o susții.

Când faci tu review, aplici aceleași reguli: comentarii despre cod, sugestii concrete, distincție clară între ce e obligatoriu și ce e preferință personală.

Ce urmărește intervievatorul: Intervievatorul verifică maturitatea în colaborare. Semnalele negative sunt defensivitatea și lipsa oricărui exemplu în care ai acceptat că ai greșit.

99 Mid

Ce faci când un termen limită nu mai poate fi respectat, de exemplu o lansare planificată în magazin?

Răspuns scurt: Anunț cât mai devreme, cu informații concrete: ce e gata, ce lipsește, ce riscuri văd și ce opțiuni există (reducerea scopului, amânarea, ascunderea unei funcționalități în spatele unui feature flag). Decizia o ia împreună cu Product Owner-ul, nu ascund problema până în ultima zi.

Ce verifică intervievatorul: dacă semnalezi riscurile la timp și dacă poți propune soluții, nu doar probleme.

Un model de răspuns:

„Lucram la un flux nou de plată care trebuia să ajungă în aplicație înaintea unei campanii. La jumătatea sprintului am descoperit că integrarea cu procesatorul de plăți cerea un pas suplimentar de autentificare, pe care nu-l estimaserăm. Am anunțat imediat la daily și apoi Product Owner-ul, cu trei opțiuni: lansăm la timp fără plata cu cardul salvat, amânăm o săptămână sau lansăm în spatele unui feature flag activat doar pentru 10% din utilizatori. Am ales prima variantă. Funcționalitatea completă a urmat în versiunea următoare.”

Elementele bune din răspuns:

  • devreme: o întârziere anunțată cu o săptămână înainte e o problemă de planificare; una anunțată în ziua lansării e o problemă de încredere;
  • fapte, nu impresii: ce e terminat, ce rămâne, de ce;
  • opțiuni: reducerea scopului, amânarea, resurse suplimentare (rareori ajută pe termen scurt), feature flags;
  • decizia e a echipei și a produsului, nu a ta singur;
  • specificul mobil: review-ul Google Play poate dura, lansarea treptată și testarea pe dispozitive iau timp, deci termenul real e mai devreme decât data de lansare.

Ce să eviți: să spui că lucrezi nopți la rând ca să recuperezi (pare eroic, dar nu e sustenabil și crește riscul de bug-uri), să dai vina pe alții sau să pretinzi că nu ai întâlnit niciodată situația. Încheie cu ce ai învățat, de exemplu că acum incluzi o marjă pentru integrările externe la estimare.

Ce urmărește intervievatorul: Se verifică transparența și orientarea spre soluții. Un plus e să ții cont de timpii specifici publicării în magazin.

100 Senior

Cum ai ajuta un developer junior nou în echipă să devină productiv?

Răspuns scurt: Îi pregătesc un onboarding clar (setup, arhitectură, convenții), îi dau la început task-uri mici și reale, fac pair programming și code review explicativ și cresc treptat autonomia, într-un mediu în care poate întreba fără teamă.

La nivel senior, o parte din valoarea ta e cât de bine îi ajuți pe ceilalți să crească. Intervievatorul caută un plan concret, nu doar „sunt disponibil pentru întrebări”.

Ce aș face, pe etape:

  • Prima zi: proiectul rulează pe laptopul lui, cu un README actualizat și acces la repository, CI și Crashlytics.
  • Prima săptămână: o prezentare de o oră a arhitecturii (module, flux de date, unde stau ViewModel-urile, cum funcționează DI), plus documentul de convenții al echipei. Primul task e mic și real, de exemplu un bug de UI, ca să treacă prin tot procesul: ramură, PR, review, merge, build.
  • Primele săptămâni: task-uri care cresc gradual ca dificultate și ating zone diferite (un ecran, apoi un repository, apoi o migrare). Pair programming pe ceva mai complicat, cu el la tastatură.
  • Code review: explic de ce, nu doar ce. Trimit link-uri spre documentație. Separ clar ce e obligatoriu de ce e preferință.
  • Feedback regulat: o discuție scurtă săptămânal la început, despre ce merge, ce e greu și ce vrea să învețe.

Un exemplu ajută: „Când a venit un coleg nou, am observat că se bloca la Hilt. Am făcut împreună o sesiune de o oră în care am construit de la zero un modul mic. După asta a început să facă singur review-uri pe codul de DI.”

Contează și siguranța: un junior care se teme să întrebe pierde zile întregi, așa că răspund la întrebări fără să le tratez ca pe o întrerupere.

Ce urmărește intervievatorul: La senior se verifică abilitatea de a multiplica productivitatea echipei. Răspunsul slab e vag și fără niciun exemplu concret.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Android Developer

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Android Developer, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Android Developer

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.