100 Android gotchas

The mistakes that come up again and again in Android code review and in interviews. Each one is the snippet people write, next to what it should be.

data class Packet(val bytes: ByteArray)

val a = Packet(byteArrayOf(1, 2))
val b = Packet(byteArrayOf(1, 2))
a == b   // false

data class Packet(val bytes: ByteArray) {
  override fun equals(other: Any?) =
    other is Packet && bytes.contentEquals(other.bytes)
  override fun hashCode() = bytes.contentHashCode()
}
// or just: data class Packet(val bytes: List<Byte>)

data class User(var name: String)

val set = mutableSetOf(User("ann"))
set.first().name = "bea"
set.contains(User("bea"))  // false

data class User(val name: String)

val set = mutableSetOf(User("ann"))
// replace instead of mutate
set.remove(User("ann"))
set.add(User("bea"))

class Id(val value: String) {
  override fun equals(other: Any?) =
    other is Id && other.value == value
  // no hashCode()
}

class Id(val value: String) {
  override fun equals(other: Any?) =
    other is Id && other.value == value
  override fun hashCode() = value.hashCode()
}

class Screen {
  var user: User? = null
  fun render() {
    if (user != null) {
      show(user!!.name)   // NPE if cleared mid-flight
    }
  }
}

class Screen {
  var user: User? = null
  fun render() {
    val u = user ?: return   // snapshot once
    show(u.name)
  }
}

open class Animal
class Dog : Animal()

fun Animal.speak() = "..."
fun Dog.speak() = "woof"

val a: Animal = Dog()
a.speak()   // "..." not "woof"

open class Animal { open fun speak() = "..." }
class Dog : Animal() { override fun speak() = "woof" }

val a: Animal = Dog()
a.speak()   // "woof"

fun setProgress(p: Int) {
  assert(p in 0..100)   // no-op on device
  field = p
}

fun setProgress(p: Int) {
  require(p in 0..100) { "progress out of range: " + p }
  field = p
}
// require -> IllegalArgumentException (bad input)
// check   -> IllegalStateException    (bad state)

items                      // 50_000 rows
  .map { it.toDomain() }   // new list
  .filter { it.isActive }  // new list
  .take(20)                // new list

items.asSequence()
  .filter { it.isActive }  // cheapest test first
  .map { it.toDomain() }
  .take(20)
  .toList()                // one list, 20 items

for (task in tasks) {
  if (task.done) tasks.remove(task)
}
// ConcurrentModificationException

tasks.removeAll { it.done }

// or, if you need the iterator:
val it = tasks.iterator()
while (it.hasNext()) if (it.next().done) it.remove()

class Cart {
  private val _items = mutableListOf<Item>()
  val items: List<Item> get() = _items
}
// caller:
(cart.items as MutableList).clear()

class Cart {
  private val _items = mutableListOf<Item>()
  val items: List<Item> get() = _items.toList()
}
// caller gets a snapshot; the cast fails

// Java: String getTitle() { return null; }
val len = javaObj.title.length
// NPE, and the compiler never warned you

val len = javaObj.title?.length ?: 0

// better: annotate the Java side
// @Nullable String getTitle()

class Api {
  companion object {
    val BASE = "https://x.dev"   // getter, not inlined
  }
}
// @Header(Api.BASE) -> compile error

class Api {
  companion object {
    const val BASE = "https://x.dev"
  }
}
// inlined at every call site, usable in annotations

sealed interface State
// later someone adds State.Error

fun render(s: State) {
  when (s) {
    is State.Loading -> spinner()
    is State.Data -> list(s.rows)
  }   // Error falls through, no warning
}

fun render(s: State) = when (s) {
  is State.Loading -> spinner()
  is State.Data -> list(s.rows)
}   // expression: adding Error breaks the build

when (result) {
  is Ok -> show(result.data)
  else -> showError()   // new Retry case lands here
}

when (result) {
  is Ok -> show(result.data)
  is Failed -> showError()
  is Retry -> showRetry()   // added by the compiler's demand
}

class Frag : Fragment() {
  private lateinit var adapter: Adapter
  override fun onCreate(b: Bundle?) {
    adapter.submit(emptyList())   // crash
  }
  override fun onViewCreated(...) { adapter = Adapter() }
}

class Frag : Fragment() {
  private val adapter by lazy { Adapter() }
  override fun onCreate(b: Bundle?) {
    adapter.submit(emptyList())   // built on first touch
  }
}

class UserViewModel : ViewModel() {
  fun load() {
    GlobalScope.launch {
      _state.value = repo.fetch()   // still running after onCleared
    }
  }
}

class UserViewModel : ViewModel() {
  fun load() {
    viewModelScope.launch {
      _state.value = repo.fetch()   // cancelled in onCleared
    }
  }
}

class MyActivity : AppCompatActivity() {
  private val scope = CoroutineScope(Dispatchers.Main)
  override fun onCreate(b: Bundle?) {
    scope.launch { poll() }
  }
  // no cancel anywhere
}

class MyActivity : AppCompatActivity() {
  override fun onCreate(b: Bundle?) {
    lifecycleScope.launch { poll() }
  }
}
// if you must own one: override onDestroy { scope.cancel() }

viewModelScope.launch {
  val bytes = File(path).readBytes()   // main thread
  _state.value = decode(bytes)
}

viewModelScope.launch {
  val bytes = withContext(Dispatchers.IO) {
    File(path).readBytes()
  }
  _state.value = decode(bytes)
}

try {
  repo.sync()
} catch (e: Exception) {
  log(e)          // eats CancellationException
  retryLater()    // keeps running after cancel
}

try {
  repo.sync()
} catch (e: CancellationException) {
  throw e
} catch (e: Exception) {
  log(e); retryLater()
}

override fun onCreate(b: Bundle?) {
  val user = runBlocking { repo.user() }   // ANR
  render(user)
}

override fun onCreate(b: Bundle?) {
  lifecycleScope.launch {
    render(repo.user())
  }
}

val user = async { api.user() }.await()
val feed = async { api.feed() }.await()
// 300ms + 300ms

coroutineScope {
  val user = async { api.user() }
  val feed = async { api.feed() }
  render(user.await(), feed.await())   // 300ms total
}

try {
  val d = async { api.user() }   // throws -> cancels parent
  render(d.await())
} catch (e: IOException) {
  showError()   // never reached
}

supervisorScope {
  val d = async { api.user() }
  try {
    render(d.await())
  } catch (e: IOException) {
    showError()
  }
}

viewModelScope.launch {
  _state.value = repo.fetch()   // IOException -> crash
}

viewModelScope.launch {
  _state.value = try {
    UiState.Data(repo.fetch())
  } catch (e: IOException) {
    UiState.Error(e.message)
  }
}

withContext(Dispatchers.IO) {
  bitmap.applyBlur(radius = 25)   // pure CPU
}

withContext(Dispatchers.Default) {
  bitmap.applyBlur(radius = 25)
}
// IO = blocking waits, Default = computation

viewModelScope.launch(Dispatchers.Default) {
  for (row in oneMillionRows) {
    heavy(row)   // no suspend point, cancel ignored
  }
}

viewModelScope.launch(Dispatchers.Default) {
  for (row in oneMillionRows) {
    ensureActive()   // or yield()
    heavy(row)
  }
}

suspend fun readConfig(): Config =
  file.readText().let(::parse)   // blocks the caller's thread

// every caller now needs withContext(IO)

suspend fun readConfig(): Config =
  withContext(Dispatchers.IO) {
    file.readText().let(::parse)
  }
// callers just call it

scope.launch(SupervisorJob()) {
  launch { a() }
  launch { b() }   // b fails -> a still cancelled
}

scope.launch {
  supervisorScope {
    launch { a() }
    launch { b() }   // b fails, a keeps going
  }
}

fun submitOrder(o: Order) {
  viewModelScope.launch {
    api.submit(o)   // user backs out -> cancelled
  }
}

fun submitOrder(o: Order) {
  WorkManager.getInstance(ctx)
    .enqueue(OneTimeWorkRequestBuilder<SubmitWorker>()
      .setInputData(o.toData()).build())
}
// survives navigation and process death

override fun onCreate(b: Bundle?) {
  lifecycleScope.launch {
    vm.state.collect { render(it) }
  }
}   // still collecting while the app is backgrounded

override fun onCreate(b: Bundle?) {
  lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
      vm.state.collect { render(it) }
    }
  }
}

val state = repo.observe()
  .stateIn(viewModelScope, SharingStarted.Eagerly, Empty)

val state = repo.observe()
  .stateIn(
    viewModelScope,
    SharingStarted.WhileSubscribed(5_000),   // rides out rotation
    Empty,
  )

private val _nav = MutableStateFlow<Route?>(null)
val nav = _nav.asStateFlow()
// rotate -> navigates a second time

private val _nav = Channel<Route>(Channel.BUFFERED)
val nav = _nav.receiveAsFlow()
// each event delivered exactly once

_state.value = UiState(count = 1)
_state.value = UiState(count = 1)   // no emission
// "retry" taps stop working

data class UiState(val count: Int, val nonce: Long = 0)

_state.update { it.copy(nonce = it.nonce + 1) }
// or keep events off the state object entirely

flow {
  withContext(Dispatchers.IO) {
    emit(db.load())   // IllegalStateException
  }
}

flow {
  emit(db.load())
}.flowOn(Dispatchers.IO)

query.collect { q ->
  repo.search(q).collect { render(it) }
  // results from an old query still arrive
}

query
  .flatMapLatest { q -> repo.search(q) }
  .collect { render(it) }
// switching query cancels the previous search

repo.rows()
  .flowOn(Dispatchers.IO)
  .map { it.heavyParse() }   // runs on Main
  .collect { render(it) }

repo.rows()
  .map { it.heavyParse() }
  .flowOn(Dispatchers.IO)    // covers rows() and map
  .collect { render(it) }

val prices = flow {
  while (true) { emit(api.prices()); delay(5_000) }
}
// two screens collect -> two polling loops

val prices = flow {
  while (true) { emit(api.prices()); delay(5_000) }
}.shareIn(scope, SharingStarted.WhileSubscribed(5_000), replay = 1)

private val _events = MutableSharedFlow<Event>()

fun send(e: Event) {
  _events.tryEmit(e)   // false while backgrounded
}

private val _events = MutableSharedFlow<Event>(
  replay = 0,
  extraBufferCapacity = 8,
  onBufferOverflow = BufferOverflow.DROP_OLDEST,
)

ticks.collect { tick ->
  renderExpensively(tick)   // 200ms
}
// emitter blocked, UI falls behind

ticks.collectLatest { tick ->
  renderExpensively(tick)   // cancelled on the next tick
}
// or .buffer() if you need every value

class MainActivity : AppCompatActivity() {
  companion object { var current: MainActivity? = null }
  override fun onCreate(b: Bundle?) { current = this }
}

class MainActivity : AppCompatActivity() {
  companion object { var current: WeakReference<MainActivity>? = null }
  override fun onCreate(b: Bundle?) { current = WeakReference(this) }
  override fun onDestroy() { current = null; super.onDestroy() }
}
// better still: don't reach for the Activity from elsewhere

handler.postDelayed({ hideBanner() }, 60_000)
// nothing cancels it on destroy

private val hide = Runnable { hideBanner() }

override fun onStart() { handler.postDelayed(hide, 60_000) }
override fun onStop() { handler.removeCallbacks(hide) }

override fun onCreate(b: Bundle?) {
  registerReceiver(netReceiver, filter)
}
// no onDestroy

override fun onStart() { registerReceiver(netReceiver, filter) }
override fun onStop() { unregisterReceiver(netReceiver) }

// or skip the pairing entirely:
// ConnectivityManager.registerNetworkCallback in a lifecycle-aware wrapper

class Frag : Fragment() {
  private lateinit var binding: FragBinding
  // never cleared -> leaks on every back-and-forward
}

class Frag : Fragment() {
  private var _binding: FragBinding? = null
  private val binding get() = _binding!!

  override fun onDestroyView() {
    _binding = null
    super.onDestroyView()
  }
}

class SearchViewModel : ViewModel() {
  var query: String = ""   // gone after a low-memory kill
}

class SearchViewModel(
  private val handle: SavedStateHandle,
) : ViewModel() {
  var query: String
    get() = handle["query"] ?: ""
    set(v) { handle["query"] = v }
}

object Analytics {
  lateinit var ctx: Context
}
// in onCreate:
Analytics.ctx = this   // the Activity

object Analytics {
  lateinit var ctx: Context
}
Analytics.ctx = applicationContext

// application scope -> application Context
// UI work (themes, dialogs, inflation) -> Activity Context

PendingIntent.getActivity(
  ctx, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT,
)   // IllegalArgumentException on API 31+

PendingIntent.getActivity(
  ctx, 0, intent,
  PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
)
// FLAG_MUTABLE only when the receiver must fill in extras

startActivity(Intent(Intent.ACTION_VIEW, uri))
// ActivityNotFoundException on a device with no browser

runCatching { startActivity(Intent(Intent.ACTION_VIEW, uri)) }
  .onFailure { showNoAppMessage() }

// plus a <queries> entry in the manifest for resolveActivity to work

// manifest has ACCESS_FINE_LOCATION
val loc = fusedClient.lastLocation   // SecurityException

val granted = ContextCompat.checkSelfPermission(
  ctx, Manifest.permission.ACCESS_FINE_LOCATION,
) == PackageManager.PERMISSION_GRANTED

if (granted) use(fusedClient.lastLocation) else launcher.launch(perm)

// from a BroadcastReceiver, app in background
context.startService(Intent(context, SyncService::class.java))
// IllegalStateException

WorkManager.getInstance(context).enqueue(
  OneTimeWorkRequestBuilder<SyncWorker>()
    .setConstraints(Constraints(requiredNetworkType = CONNECTED))
    .build(),
)

api.load { result ->
  supportFragmentManager.beginTransaction()
    .replace(R.id.host, ResultFragment())
    .commit()   // IllegalStateException if backgrounded
}

lifecycleScope.launch {
  repeatOnLifecycle(Lifecycle.State.STARTED) {
    vm.result.collect { showResultFragment(it) }
  }
}
// only commits while the state is safe to change

override fun onCreate(b: Bundle?) {
  if (!loggedIn) finish()
  setContentView(R.layout.main)
  loadProfile()   // still runs, often crashes
}

override fun onCreate(b: Bundle?) {
  if (!loggedIn) { finish(); return }
  setContentView(R.layout.main)
  loadProfile()
}

@Composable
fun Counter() {
  var n by mutableStateOf(0)   // new state each pass
  Button({ n++ }) { Text("$n") }   // always 0
}

@Composable
fun Counter() {
  var n by remember { mutableStateOf(0) }
  Button({ n++ }) { Text("$n") }
}

@Composable
fun Row(user: User) {
  val initials = remember { user.name.initials() }
  Text(initials)   // still the first user's initials
}

@Composable
fun Row(user: User) {
  val initials = remember(user.name) { user.name.initials() }
  Text(initials)
}

var query by remember { mutableStateOf("") }
// rotate -> the search box is empty again

var query by rememberSaveable { mutableStateOf("") }
// survives rotation and process death

@Composable
fun Detail(id: String, vm: VM) {
  LaunchedEffect(Unit) { vm.load(id) }
  // navigate to another id -> never reloads
}

@Composable
fun Detail(id: String, vm: VM) {
  LaunchedEffect(id) { vm.load(id) }
  // relaunches (and cancels the old load) per id
}

@Composable
fun Screen(vm: VM) {
  vm.viewModelScope.launch { vm.refresh() }   // per recomposition
  ...
}

@Composable
fun Screen(vm: VM) {
  LaunchedEffect(Unit) { vm.refresh() }       // once per entry
  // for callbacks: val scope = rememberCoroutineScope()
}

val items = remember { mutableStateOf(mutableListOf<Item>()) }
items.value.add(item)   // no recomposition

val items = remember { mutableStateListOf<Item>() }
items.add(item)

// or keep it immutable:
// items.value = items.value + item

LazyColumn {
  items(rows) { row -> Card(row) }
}
// delete row 0 -> row 1 inherits its expanded state

LazyColumn {
  items(rows, key = { it.id }) { row -> Card(row) }
}

LazyColumn {
  item {
    Column(Modifier.verticalScroll(rememberScrollState())) { ... }
  }
}   // IllegalStateException: infinite maximum height

LazyColumn {
  item { Header() }
  items(rows, key = { it.id }) { Row(it) }
  item { Footer() }
}
// one scroller, one list

@Composable
fun Screen() {
  analytics.log("screen_view")   // once per recomposition
  ...
}

@Composable
fun Screen() {
  LaunchedEffect(Unit) { analytics.log("screen_view") }
  ...
}

val showTop = listState.firstVisibleItemIndex > 0
// recomposes on every scroll frame

val showTop by remember {
  derivedStateOf { listState.firstVisibleItemIndex > 0 }
}
// recomposes only when the boolean flips

val state by vm.state.collectAsState()

val state by vm.state.collectAsStateWithLifecycle()
// stops at STOPPED, restarts at STARTED

LaunchedEffect(Unit) {
  sensor.registerListener(cb)   // never unregistered
}

DisposableEffect(sensor) {
  sensor.registerListener(cb)
  onDispose { sensor.unregisterListener(cb) }
}

Box(
  Modifier
    .padding(16.dp)
    .background(Blue)   // blue does NOT cover the padding
    .clickable { }      // ripple misses the padding too
)

Box(
  Modifier
    .background(Blue)
    .clickable { }
    .padding(16.dp)     // inner padding, full-size touch target
)

@Composable
fun UserCard(vm: UserViewModel) {
  Text(vm.state.value.name)
  Button({ vm.refresh() }) { Text("Refresh") }
}

@Composable
fun UserCard(name: String, onRefresh: () -> Unit) {
  Text(name)
  Button(onRefresh) { Text("Refresh") }
}
// the ViewModel stays at the screen root

class ProfileViewModel(
  private val activity: Activity,
) : ViewModel() {
  fun title() = activity.getString(R.string.profile)
}

class ProfileViewModel(
  @ApplicationContext private val ctx: Context,
) : ViewModel() {
  fun title() = ctx.getString(R.string.profile)
}
// better: expose a resource id and let the UI resolve it

class VM : ViewModel() {
  val state = MutableStateFlow(UiState())
}
// fragment: vm.state.value = UiState(loading = true)

class VM : ViewModel() {
  private val _state = MutableStateFlow(UiState())
  val state: StateFlow<UiState> = _state.asStateFlow()

  fun refresh() { _state.update { it.copy(loading = true) } }
}

// in the Fragment
val price = items.sumOf { it.price } *
  if (user.isPrime) 0.9 else 1.0
priceView.text = format(price)

// domain
class CartTotal {
  operator fun invoke(items: List<Item>, user: User) = ...
}
// fragment
priceView.text = format(state.total)

class Frag : Fragment() {
  private val vm = ProfileViewModel()   // new one per rotation
}

class Frag : Fragment() {
  private val vm: ProfileViewModel by viewModels()
}
// scoped to the fragment; by activityViewModels() to share

@Singleton
class Tracker @Inject constructor(
  private val activity: Activity,   // ActivityComponent
)
// error: cannot be provided in SingletonComponent

@Singleton
class Tracker @Inject constructor(
  @ApplicationContext private val ctx: Context,
)
// pass per-screen data in as method arguments

@HiltViewModel
class FeedViewModel(
  private val repo: FeedRepository,
) : ViewModel()

@HiltViewModel
class FeedViewModel @Inject constructor(
  private val repo: FeedRepository,
) : ViewModel()

class Prefs @Inject constructor(
  private val ctx: Context,   // which one?
)

class Prefs @Inject constructor(
  @ApplicationContext private val ctx: Context,
)
// @ActivityContext for anything that touches UI

val loading = MutableStateFlow(false)
val data = MutableStateFlow<List<Row>>(emptyList())
val error = MutableStateFlow<String?>(null)
// can be loading AND error at once

sealed interface UiState {
  data object Loading : UiState
  data class Data(val rows: List<Row>) : UiState
  data class Error(val message: String) : UiState
}
val state = MutableStateFlow<UiState>(UiState.Loading)

@Serializable
data class UserDto(val first_name: String?, val avatar_url: String?)

Text(user.first_name ?: "")   // in the UI

data class User(val name: String, val avatar: String)

fun UserDto.toDomain() = User(
  name = first_name.orEmpty(),
  avatar = avatar_url ?: DEFAULT_AVATAR,
)

interface Repo {
  suspend fun user(): Response<UserDto>
}
// ViewModel: if (r.isSuccessful) r.body()!! else ...

interface Repo {
  suspend fun user(): Result<User>
}
// ViewModel: result.fold(::show, ::showError)

@Dao interface UserDao {
  @Query("SELECT * FROM user") fun all(): List<User>
}
val users = dao.all()   // IllegalStateException on main

@Dao interface UserDao {
  @Query("SELECT * FROM user") suspend fun all(): List<User>
  @Query("SELECT * FROM user") fun observe(): Flow<List<User>>
}

Room.databaseBuilder(ctx, Db::class.java, "app.db")
  .fallbackToDestructiveMigration()
  .build()

val MIGRATION_1_2 = object : Migration(1, 2) {
  override fun migrate(db: SupportSQLiteDatabase) {
    db.execSQL("ALTER TABLE user ADD COLUMN nickname TEXT")
  }
}
Room.databaseBuilder(...).addMigrations(MIGRATION_1_2).build()

interface Api { @GET("user") fun user(): Call<UserDto> }

val user = api.user().execute().body()   // blocks

interface Api { @GET("user") suspend fun user(): UserDto }

val user = withContext(Dispatchers.IO) { api.user() }

fun fetch(url: String) =
  OkHttpClient().newCall(Request.Builder().url(url).build())

@Singleton
class Http @Inject constructor() {
  val client = OkHttpClient.Builder().build()
}
// one client per app; .newBuilder() to vary timeouts

val res = client.newCall(req).execute()
if (res.isSuccessful) return res.body!!.string()
return null   // body never closed on the failure path

client.newCall(req).execute().use { res ->
  if (res.isSuccessful) res.body?.string() else null
}

val json = Json   // ignoreUnknownKeys = false
json.decodeFromString<UserDto>(body)
// SerializationException on a new server field

val json = Json {
  ignoreUnknownKeys = true
  coerceInputValues = true
  explicitNulls = false
}

class Prefs(ctx: Context) {
  private val store = PreferenceDataStoreFactory.create { ctx.prefsFile() }
}
// two Prefs -> IllegalStateException

// top level, once per process
val Context.dataStore by preferencesDataStore(name = "settings")

class Prefs @Inject constructor(
  @ApplicationContext private val ctx: Context,
) { private val store = ctx.dataStore }

prefs.edit().putBoolean("dark", true).commit()

prefs.edit { putBoolean("dark", true) }   // apply(), async

// better: DataStore, which is suspend by construction
store.edit { it[DARK] = true }

@Dao interface FeedDao {
  suspend fun clear()
  suspend fun insert(rows: List<Row>)
}
dao.clear(); dao.insert(rows)   // empty list in between

@Dao interface FeedDao {
  @Transaction
  suspend fun replace(rows: List<Row>) {
    clear()
    insert(rows)
  }
}

.baseUrl("https://api.x.dev/v2")
@GET("users") // -> https://api.x.dev/users  (v2 dropped)

.baseUrl("https://api.x.dev/v2/")
@GET("users") // -> https://api.x.dev/v2/users

// a leading slash on the path also discards the base path

@Test fun retries() = runBlocking {
  repo.syncWithBackoff()   // actually sleeps 30s
  assertEquals(3, api.calls)
}

@Test fun retries() = runTest {
  repo.syncWithBackoff()   // virtual time, instant
  assertEquals(3, api.calls)
}

class Repo {
  suspend fun load() = withContext(Dispatchers.IO) { ... }
}

class Repo(private val io: CoroutineDispatcher = Dispatchers.IO) {
  suspend fun load() = withContext(io) { ... }
}
// test: Repo(StandardTestDispatcher(testScheduler))

@Test fun loads() = runTest {
  val vm = FeedViewModel(repo)   // IllegalStateException
}

@Before fun setUp() = Dispatchers.setMain(StandardTestDispatcher())
@After  fun tearDown() = Dispatchers.resetMain()

// or a @get:Rule MainDispatcherRule

@Test fun state() = runTest {
  vm.load()
  assertEquals(Data(rows), vm.state.value)   // still Loading
}

@Test fun state() = runTest {
  vm.state.test {           // Turbine subscribes
    assertEquals(Loading, awaitItem())
    vm.load()
    assertEquals(Data(rows), awaitItem())
  }
}

assertEquals(Data(rows), vm.state.first())
// Loading -> Error -> Data would also pass

vm.state.test {
  assertEquals(Loading, awaitItem())
  assertEquals(Data(rows), awaitItem())
  cancelAndConsumeRemainingEvents()
}

onView(withId(R.id.load)).perform(click())
Thread.sleep(2_000)
onView(withText("Ann")).check(matches(isDisplayed()))

composeRule.onNodeWithTag("load").performClick()
composeRule.waitUntil(timeoutMillis = 5_000) {
  composeRule.onAllNodesWithText("Ann")
    .fetchSemanticsNodes().isNotEmpty()
}

dependencies {
  api(libs.retrofit)      // leaks Retrofit to every consumer
  api(libs.okhttp)
}

dependencies {
  implementation(libs.retrofit)
  // api only for types that appear in this module's public signatures
}

# proguard-rules.pro
# (empty)

# debug parses fine, release returns a DTO with every field null,
# because R8 renamed the fields Gson looks up by name

# proguard-rules.pro
-keepclassmembers,allowobfuscation class * {
  @com.google.gson.annotations.SerializedName <fields>;
}

# or move to kotlinx.serialization, which needs no reflection

release {
  isMinifyEnabled = false
  isShrinkResources = false
}

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

val bmp = BitmapFactory.decodeFile(path)
imageView.setImageBitmap(bmp)   // OutOfMemoryError

imageView.load(File(path)) {
  size(imageView.width, imageView.height)
}
// by hand: BitmapFactory.Options(inSampleSize = n)

fun submit(rows: List<Row>) {
  this.rows = rows
  notifyDataSetChanged()
}

class RowAdapter : ListAdapter<Row, VH>(DIFF) {
  companion object {
    val DIFF = object : DiffUtil.ItemCallback<Row>() {
      override fun areItemsTheSame(a: Row, b: Row) = a.id == b.id
      override fun areContentsTheSame(a: Row, b: Row) = a == b
    }
  }
}

class App : Application() {
  override fun onCreate() {
    Analytics.init(this)
    Crash.init(this)
    Ads.init(this)      // 400ms before any UI
  }
}

class App : Application() {
  override fun onCreate() {
    Crash.init(this)    // must be first, keep it
  }
}
// the rest: androidx.startup Initializer, or lazy on first use

override fun onBindViewHolder(h: VH, i: Int) {
  val user = db.userDao().byId(rows[i].userId)   // disk read
  h.name.text = formatDate(rows[i].at)           // allocates
}

// map to a ready-to-render model off the main thread
data class RowUi(val name: String, val date: String)

override fun onBindViewHolder(h: VH, i: Int) {
  h.name.text = getItem(i).name
  h.date.text = getItem(i).date
}

prefs.edit { putString("access_token", token) }

val keyAlias = MasterKey.Builder(ctx)
  .setKeyScheme(MasterKey.KeyScheme.AES256_GCM).build()

EncryptedSharedPreferences.create(
  ctx, "secure", keyAlias, AES256_SIV, AES256_GCM,
).edit { putString("access_token", token) }

val tm = object : X509TrustManager {
  override fun checkServerTrusted(c: Array<X509Certificate>, a: String) {}
  override fun checkClientTrusted(c: Array<X509Certificate>, a: String) {}
  override fun getAcceptedIssuers() = arrayOf<X509Certificate>()
}

// res/xml/network_security_config.xml for debug-only trust,
// and pin the production host:
val pinner = CertificatePinner.Builder()
  .add("api.x.dev", "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
  .build()
OkHttpClient.Builder().certificatePinner(pinner).build()

<receiver
  android:name=".SyncReceiver"
  android:exported="true" />

<receiver
  android:name=".SyncReceiver"
  android:exported="false" />

<!-- if it genuinely must be public, gate it: -->
<!-- android:permission="com.x.permission.SYNC" -->

Log.d("Api", "auth=" + token)
HttpLoggingInterceptor().setLevel(Level.BODY)   // in release

HttpLoggingInterceptor()
  .apply { level = if (BuildConfig.DEBUG) Level.BASIC else Level.NONE }
  .apply { redactHeader("Authorization") }