aartikov

fun ComponentContext.componentCoroutineScope(): CoroutineScope {
   val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)

   if (lifecycle.state != Lifecycle.State.DESTROYED) {
       lifecycle.doOnDestroy {
           scope.cancel()
       }
   } else {
       scope.cancel()
   }

surajsau

@Composable
fun ParallaxScreen(modifier: Modifier = Modifier) {
    val context = LocalContext.current
    val scope = rememberCoroutineScope()

    var data by remember { mutableStateOf<SensorData?>(null) }

    DisposableEffect(Unit) {
        val dataManager = SensorDataManager(context)
        dataManager.init()

burnoo

private class MutableStateAdapter<T>(
    private val state: State<T>,
    private val mutate: (T) -> Unit
) : MutableState<T> {

    override var value: T
        get() = state.value
        set(value) {
            mutate(value)
        }

wasabeef

./gradlew clean buildRelease publish

jevakallio

TL;DR;

com.package.name is your app identifier, and the file path is relative to the app user's home directory, e.g. '/data/user/0/com.package.name.

adb shell run-as com.package.name cp relative/path/file.ext /sdcard
adb pull /sdcard/file.ext

See long explanation below.

makiftutuncu

sealed class Option<out A>(open val value: A?) {
    fun <B> fold(ifNone: () -> B, ifSome: (A) -> B): B =
        when (this) {
            is None -> ifNone()
            is Some -> ifSome(this.value)
        }
    
    // This doesn't compile because `out` type A is in `in` position
    fun getOrElseThatWontWork(default: () -> A): A =
        when (this) {

karangoel16

fun String.toTransparentColor(num: Int): String {
    return "#" + when (num) {
        100 -> "FF"
        99 -> "FC"
        98 -> "FA"
        97 -> "F7"
        96 -> "F5"
        95 -> "F2"
        94 -> "F0"

wilik16

android {
    applicationVariants.all { variant ->
        variant.outputs.all {
            def fileName = "app"
            switch (variant.buildType.name) {
                case "debug":
                    fileName = "${appNameDebug}-${variant.versionCode}"
                    break
                case "release":
                    fileName = "${appNameRelease}-${variant.versionCode}"

fay59

Here's a list of mildly interesting things about the C language that I learned mostly by consuming Clang's ASTs. Although surprises are getting sparser, I might continue to update this document over time.

There are many more mildly interesting features of C++, but the language is literally known for being weird, whereas C is usually considered smaller and simpler, so this is (almost) only about C.

1. Combined type and variable/field declaration, inside a struct scope [https://godbolt.org/g/Rh94Go]

struct foo {
   struct bar {
 int x;

JoseAlcerreca

/**
 * An [Observer] for [Event]s, simplifying the pattern of checking if the [Event]'s content has
 * already been handled.
 *
 * [onEventUnhandledContent] is *only* called if the [Event]'s contents has not been handled.
 */
class EventObserver<T>(private val onEventUnhandledContent: (T) -> Unit) : Observer<Event<T>> {
    override fun onChanged(event: Event<T>?) {
        event?.getContentIfNotHandled()?.let { value ->
            onEventUnhandledContent(value)