View

GONE

LiveData

LiveData

kotin stdlib

kotlin

kotlin-android

org.jetbrains.kotlin:kotlin-stdlib:${versions.kotlin}

android {
  ...
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }

  kotlinOptions {
    jvmTarget = "1.8"
  }
}

compileOptions

kotlinOptions.jvmTarget="11"

lintOptions {
        isAbortOnError = false
    }

java.lang.NoSuchMethodError: No static method getSeconds(I)D in class Lkotlin/time/DurationKt; or its super classes (declaration of 'kotlin.time.DurationKt'

kotlin-stdlib

java

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
        vendor = JvmVendorSpec.ADOPTOPENJDK
    }
}

[Jetpack Proto DataStore]

protobuf {
  protoc {
    artifact = 'com.google.protobuf:protoc:3.8.0'
  }
  generateProtoTasks {
    all().each { task ->
      task.builtins {
        java {
          option "lite"
        }
      }
    }
  }
}

startActivityForResult

onActivityResult

startActivityForResult

kotlinOptions {
    freeCompilerArgs += [
            '-Xsam-conversions=class',
    ]
}

private fun cmToFeet(value: String): String {
    var text = ""
    val cm = value.toDouble()
    val feet = floor((cm / 2.54) / 12)
    val inches = round((cm / 2.54) - (feet * 12))
    if (feet > 0 && feet < 10) {
        text = "${feet.toInt()}'"
        if (inches > 0) {
            text += "${inches.toInt()}\""
        }
    }
    return text
}

LiveData

MediatorLiveData

StateFlow

import androidx.lifecycle.LiveData
import androidx.lifecycle.MediatorLiveData
import androidx.lifecycle.MutableLiveData

abstract class InputFrom {
    private val _isFromValid = MediatorLiveData<Boolean>()
    val isFromValid: LiveData<Boolean>
        get() = _isFromValid

    abstract val fields: List<LiveInputField<*>>

    fun init() {
        fields.forEach { inputField ->
            _isFromValid.addSource(inputField.value) { changedValue ->
                inputField.validate(changedValue)
                _isFromValid.value = fields.all {
                    it.isValid
                }
            }
        }
    }

    inner class LiveInputField<T>(
        private val errorMessage: String? = null,
        private val predicate: (T?) -> Boolean
    ) {

        val value = MutableLiveData<T>()

        private val _error = MutableLiveData<String>()
        val errorText: LiveData<String>
            get() = _error

        var isValid: Boolean = false

        fun validate(value: Any?) {
            @Suppress("UNCHECKED_CAST")
            return if (predicate(value as? T)) {
                _error.value = null
                isValid = true
            } else {
                _error.value = errorMessage
                isValid = false
            }
        }
    }
}

class LoginFrom : InputFrom() {

    val username =
        LiveInputField<String>("At least 4 characters, only letters, numbers, ., _ allowed.") {
            !it.isNullOrBlank() &&
                Pattern.compile("[a-zA-Z0-9_.]{4,}")
                    .matcher(it)
                    .matches()
        }

    val password =
        LiveInputField<String>(
            "8 characters or more, at least one number, one uppercase, one lowercase."
        ) {
            !it.isNullOrBlank()/* &&
          Pattern.compile("((?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{8,})")
              .matcher(it)
              .matches()*/
        }

    override val fields: List<LiveInputField<*>>
        get() = listOf(
            username,
            password
        )
}

ViewCompat.setOnApplyWindowInsetsListener(this) { _, windowInsets ->
    val statusBarInsets = windowInsets.getInsets(WindowInsetsCompat.Type.statusBars())
    val statusBarHeight: Int = <http://statusBarInsets.top|statusBarInsets.top>
}