marcellogalhardo

@Composable
internal fun <T> rememberRetained(
    owner: ViewModelStoreOwner = LocalViewModelStoreOwner.current!!
    key: String? = null,
    block: @DisallowComposableCalls CreationExtras.() -> T,
): T {
    val wrapperViewModel = viewModel(owner, key) { WrapperViewModel(block()) }
    return remember(owner, key) { wrapperViewModel.instance }
}

marcellogalhardo

package provider

internal class MutableProviderImpl<T>(
    scope: ProviderScope? = null,
    private val factory: InstanceFactory<T>? = null,
) : ReadWriteProvider<T> {

    init {
        require(scope is ProviderScopeImpl)
        scope.listeners.add { value = null }

marcellogalhardo

package logcat

public object LogClient {

    private var isInitialized: Boolean = false

    @PublishedApi
    internal var isEnabled: Boolean = false

    @PublishedApi

marcellogalhardo

package coroutines

/**
 * Calls the specified function [block] and returns its encapsulated result if invocation was
 * successful, catching any [Throwable] exception that was thrown from the block function execution
 * and encapsulating it as a failure.
 *
 * Unlike [runCatching], [suspendRunCatching] does not break structured concurrency by rethrowing
 * any [CancellationException].
 *

marcellogalhardo

fun ComponentActivity.lazySavedStateHandle(
        key: String = this::class.java.canonicalName,
        defaultState: Bundle? = intent?.extras,
): Lazy<SavedStateHandle> = lazy(LazyThreadSafetyMode.NONE) {
    SavedStateHandle(savedStateRegistry, key, defaultState)
}

fun Fragment.lazySavedStateHandle(
        key: String = this::class.java.canonicalName,
        defaultState: Bundle? = arguments,

marcellogalhardo

import kotlinx.coroutines.CancellationException
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract

/**
 * A discriminated union that encapsulates a successful outcome with a value of type [T]
 * or a failure with an arbitrary [Throwable] exception.
 *
 * While using Kotlin's [Result] with [runCatching] method is very simple, there are some flaws:

marcellogalhardo

import android.app.Activity
import android.content.pm.PackageManager
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue

marcellogalhardo

/**
 * Invokes [otherwise] if the [value] is false.
 */
@OptIn(ExperimentalContracts::class)
inline fun guard(value: Boolean, otherwise: () -> Unit) {
    contract {
        returns() implies value
    }

    if (!value) otherwise()

marcellogalhardo

# Android
android.enableJetifier=false
android.nonTransitiveRClass=true
android.useAndroidX=true
# Android Experimental
android.enableR8.fullMode=true
android.experimental.cacheCompileLibResources=true
android.experimental.enableSourceSetPathsMap=true
# Build Features: https://developer.android.com/reference/tools/gradle-api/7.0/com/android/build/api/dsl/BuildFeatures
android.defaults.buildfeatures.aidl=true

marcellogalhardo

import androidx.fragment.app.DialogFragment
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentFactory
import androidx.fragment.app.FragmentManager

/**
 * Create a new instance of a [Fragment] with the given class name. This uses
 * [FragmentFactory.loadFragmentClass] and the empty constructor of the resulting
 * [Class] by default.
 *