@Composable
fun Reproduce() {
    var currentRoute: String? = null
    val expr = currentRoute != null && shouldShowBottomNav(currentRoute)
}

@Composable
fun shouldShowBottomNav(currentRoute: String): Boolean {
    return true
}

@Composable

~/.android

~/.gradle

org.jetbrains.kotlin.codegen.CompilationException: Back-end (JVM) Internal error: Couldn't inline method call: remember { mutableStateOf("test") }

Bad notification posted from package: x Couldn't create icon: StatusBarIcon

.png

MutableSharedFlow<Unit>(replay = 0)

maven { url "<https://jitpack.io>" }

private fun webViewSettings(url: String) {

    activityWebBinding.webView.settings.apply {
        javaScriptEnabled = true
        domStorageEnabled = true
        builtInZoomControls = true
        displayZoomControls = false
        javaScriptCanOpenWindowsAutomatically = true
        cacheMode = WebSettings.LOAD_DEFAULT
        setAppCachePath(applicationContext.cacheDir.absolutePath)

        defaultZoom = WebSettings.ZoomDensity.FAR
        loadWithOverviewMode = true
        useWideViewPort = true
        allowFileAccess = true
        allowContentAccess = true
        setSupportZoom(true)
        layoutAlgorithm = WebSettings.LayoutAlgorithm.SINGLE_COLUMN

        setRenderPriority(WebSettings.RenderPriority.HIGH)
        mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW

        setSupportMultipleWindows(true)
    }

    activityWebBinding.webView.apply {
        if (Build.VERSION.SDK_INT >= 22) {
            setLayerType(View.LAYER_TYPE_HARDWARE, null)
        } else {
            setLayerType(View.LAYER_TYPE_SOFTWARE, null)
        }
        scrollBarStyle = View.SCROLLBARS_INSIDE_OVERLAY
        isScrollbarFadingEnabled = true
        setBackgroundColor(Color.TRANSPARENT)
        loadUrl(url)
    }
}

fun loadBlogArticles(onSuccess: (List<Blog>) -> Unit, onError: () -> Unit) {
    val request = Request.Builder()
            .get()
            .url(BLOG_ARTICLES_URL)
            .build()

    executor.execute {
        runCatching {
            val response: Response = client.newCall(request).execute()
            response.body?.string()?.let { json ->
                gson.fromJson(json, BlogData::class.java)?.let { blogData ->
                    return@runCatching blogData.data
                }
            }
        }.onFailure { e: Throwable ->
            Log.e("BlogHttpClient", "Error loading blog articles", e)
            onError()
        }.onSuccess { value: List<Blog>? ->
            onSuccess(value ?: emptyList())
        }
    }
}

public abstract void onResult(@NonNull List<Value> data, int position, int totalCount,
        @Nullable Key previousPageKey, @Nullable Key nextPageKey);

override fun toString(): String {
    return when (this) {
        is Success<*> -> "Success[data=$data]"
        is Error -> "Error[exception=$exception]"
    }
}

@Singleton
class AuthenticationInterceptor @Inject constructor(profileRepository: ProfileRepository, @ApplicationScope coroutineScope: CoroutineScope) :
    Interceptor {

    private val tokenFlow: Flow<String?> = profileRepository.getProfileToken()
        .stateIn(coroutineScope, SharingStarted.Eagerly, null)

    override fun intercept(chain: Interceptor.Chain): Response {
        val requestBuilder = chain.request().newBuilder()
        val token: String? = runBlocking { // this line should be changed
            tokenFlow.firstOrNull()
        }
        token?.let { requestBuilder.addHeader("Authorization", it) }
        return chain.proceed(requestBuilder.build())
    }
}

Fragment.onCreate

lifecycleScope.launch { ... }

…

…

launch {}

IdlingResources

ViewModel

Fragment

val list = mutableListOf<String>("10", "0.1", "0.01", "1")
        list.sortBy { // default kotlin in-place sorter
            it
        }
        list.sortByStringValue {
            if (it.toDoubleOrNull() == null) {
                it
            } else {
                it.toDouble()
            }
        }

Not Kotlin

SavedStateHandle

Flow

class MyViewModel<State>(
    private val savedStateHandle: SavedStateHandle,
    initialState: State,
) : ViewModel() {
    private var _state by mutableStateOf(initialState)
    val state: State
        get() = _state

    init {
        viewModelScope.launch {
            savedStateHandle.getFlow(STATE, initialState)
                .collect { _state = it }
        }
    }

    fun updateState(reducer: State.() -> State) =
        savedStateHandle.set(STATE, state.reducer())

    companion object {
        private const val STATE = "state"
    }
}

get

set

savedStateHandle

0111 user will not allow displaying in edit text. only 111 is allowed

1101 it can allow zero in middle.

viewModelScope.launch

ViewModel

init

SavedInstanceState.getLiveData

Flow

asFlow

init

InstantTaskExecutorRule

init