Is there any way for fast scroll for

LazyLazyState

?

animateScrollToItem

for long distance scroll, it animates all the way to the index, which takes too long time. Need to animate the scroll at initial, teleport to some nearest index and animate from there to the index.

Does Compose generate a baseline-profile by default if you plug the profileinstaller library even without generating your own

baseline-prof.txt

file?

Any idea why the dropdown menu gets moved to the top-left of the screen instead of being right below the

ExposedDropdownMenuBox

? Code in thread.

What is the “touch slop” ? I’ve encountered this term in

PointerInputScope.detectTransformGestures()

docstring but I can’t make sense of what it means.

I cant recall the article, but I recently read about how lambdas are grouped in classes in compose (and thats one of the reasons why release builds are so much faster than debug). Does the same thing happen if the lambda is wrapped inside a value class? Example in thread 🧵

Where is the code located that is responsible for the IDE preview creation?

Anyone got clue about what parameters allows to fix text overlapping when using very large fontSize?

Hello all, wondering if someone can help me understand LayColumn’s contentPadding and its relation to ListState.layoutInfo.viewportStartOffset. Example code in reply

Has anyone else had trouble with their Compose app crashing on release builds with R8 enabled? Running into a weird crash on one of the screens in my app that seems to be related to the number of composables being drawn on screen at once. For example, if I comment out a few of my composables on that screen, the crash doesn't occur (doesn't matter which ones I comment out). Happens on both 1.1.1 and 1.2.0-rc02. Are there any ProGuard / R8 rules specific to Compose that I'm missing?

I’m trying to make the scroll position of my Composable available in the View world, but I’m having trouble.

//I create a scroll state in my view model and pass it here to be used
val scrollState = rememberSaveable(saver = ScrollState.Saver) { viewModel.state.scrollState }

//Add to my column
Modifier.verticalScroll(scrollState)

//In on save instance state of an Android View I grab the state and save it to a bundle
savedState.scrollPosition = viewModel.state.scrollState.value

However, the scroll state’s value is always 0. Am I going about this all wrong?

Hello :android-wave: , I'm currently trying to wrap some text around an image like the screenshot below. Does anyone have an idea if there's an API that exists in Compose to do this? Or is this a custom Canvas thing that I need to look into?

What is the proper way to scroll a lazy list so that the item is centered with items of different sizes? If the item is not visible yet we don't have the size yet.

Hi everyone! Can you explain me what is the different between the codes below ? And on LaunchedEffect block, if the key is changed during the block the LaunchedEffect is re launched again before the block is finished? @galex @Mor Amit

LaunchedEffect(shouldLoadMore) {
        if (shouldLoadMore.value) {
            lastTotalItems = state.layoutInfo.totalItemsCount
            onEndReached()
        }
    }

=========================

 LaunchedEffect(shouldLoadMore) {
        snapshotFlow { shouldLoadMore.value }
            .collect { shouldLoadMore ->
                if (shouldLoadMore){
                    lastTotalItems = state.layoutInfo.totalItemsCount
                    onEndReached()
                }
            }
    }

Does anyone know of 1.2.0 will break binary compatibility or not with 1.1.1? I know from 1.0 to 1.1 i had a few issues as some function signatures changed. Also, will it force me into updating my target sdk? We're still in the process of getting ready to update to 31 (though we compile with 31, we still target 30)

I'm using the exoplayer lib and a problem I have is that fading doesn't work, so it just pops in and out. Is there some way to fix this?

@Composable
fun Player(
    modifier: Modifier = Modifier,
    player: Player,
) = DisposableEffect(
    AndroidView(
        modifier = Modifier
            .aspectRatio(16f / 9f)
            .then(modifier),
        factory = { context ->
            PlayerView(context).apply {
                this.player = player
                useController = false
                useArtwork = true
                resizeMode = AspectRatioFrameLayout.RESIZE_MODE_FIT
            }
        }
    )
) {
    onDispose(player::release)
}

Is it advisable to create inner functions in compose, is there any performance hit to doing something like this or should inner functions be strictly remembered?

@Composable
fun App(){
    fun someInnerComputationFunction(input: Int): Int{
       //do some computation and return an integer
    }
 
 Box(modifier = Modifier.fillMaxSize()){

 }
  
}

I want to “reveal” a bottom sheet like content once the user scrolls beyond the end of a

LazyColumn

Showing that content should behave like a bottom sheet (collapsing or expanding if too little/enough drag) Using

nestedScroll

and

swipeable

seems the way to go but I’m struggling as the List also needs to be full-height and nesting vertically scrollable maxHeight layouts is disallowed. Any ideas?

Hello every one!!, I have a useCase return flow of list<item>, I want to emit this data two times from one useCase. Return data is correct but my lazy column just recompose 1 time, and the next data is update after scroll… Code in thread:

Is there a more concise way to notify on stop events than this?

val lifecycleOwner = LocalLifecycleOwner.current
    DisposableEffect(lifecycleOwner) {
        val observer = LifecycleEventObserver { _, event ->
            if (event == Lifecycle.Event.ON_STOP) {
                viewModel.onStop()
            }
        }

        lifecycleOwner.lifecycle.addObserver(observer)
        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }

Hello, I'm having a base class like this:

abstract class Scene : JavaScene() { // JavaScene is a Java class
    private var composition: Composition? = null

    fun setContent(content: @Composable () -> Unit) {
        composition = Composition(/* ... */).apply { setContent(content) }
    }
}

and a subclass like this:

class MyScene : Scene() {
    override fun init() { // From JavaScene
        setContent { /* ... */ }
    }
}

Nothing complains during the compile time, but at the runtime when

init

gets called,

Scene.setContent

throws an error:

androidx.compose.runtime.internal.ComposableLambdaImpl cannot be cast to kotlin.jvm.functions.Function0

. How to fix that?

I feel like am missing something fundamental from my mental model of how compose works 😅, could anyone point me to the right direction? I am trying to use a value from LocalConfiguration in a heavy-ish calculation like this:

val calculationResult by remember { derivedStateOf {
    val primaryLocale = LocalConfiguration.current.locales.get(0) // error
    // Some filtering, calculations, etc.
} }

Obviously this doesn't work, since CompositionLocal.current is @Composable and results in an error. If I store the Configuration outside of the derivedStateOf block, it won't work either since it doesn't observe that State is being read and won't update.

val configuration = LocalConfiguration.current
val calculationResult by remember { derivedStateOf {
    val primaryLocale = configuration.locales.get(0)
    // Some filtering, calculations, etc.
} }
// Doesn't update

What would be an idiomatic/correct way to achieve what I'm trying to do here?

https://issuetracker.google.com/179203700 Is there a workaround available for this issue?

I’m trying to use the

swipeable

modifier in a CoordinatorLayout but it is only working Horizontal but not Vertical https://gist.github.com/thebino/4c95e46cca53ec1d9baa29953f0ccb20#file-mainactivity-kt-L79

Wrote an article talking about the lint rules that Compose ships with by default and where to even find these lint rules. Finally, I talk about how you can update the severity of some of the default rules if it makes sense for your codebase. Read here - https://www.jetpackcompose.app/articles/which-lint-rules-does-jetpack-compose-ship-with

Its weird that there’s a BottomSheetScaffold but not a

ModalBottomSheetScaffold

🤔 why is that? just the case of yet to be created?

I'm using compose destinations for navigation in my app, and when navigating between screens on my bottom bar, it loses the scroll position in a lazy column I have placed. My navigation code:

navController.navigate(destination.direction) {
    popUpTo(navController.navGraph.startRoute) {
        saveState = true
    }
    launchSingleTop = true
    restoreState = true
}

Hi, I’m studying the inside of a compose SlotTable. Is the

invalidateGroupsWithKey(key: Int)

function in SlotTable only used for testing? I followed the final call of invalidateGroupsWithKey and arrived at the invalidateGroupsWithKey function with @TestOnly attached, and this function is not used. I figured out that the only use case of the

findEffectiveRecomposeScope(group: Int)

function, which is i think an important function of SlotTable, is invalidateGroupsWithKey, and I wanted to know where invalidateGroupsWithKey is called.

@TestOnly
fun invalidateGroupsWithKey(key: Int) = HotReloader.invalidateGroupsWithKey(key)

And in the process of reaching final TestOnly function, I saw a function like the one below.

fun invalidateGroupsWithKey(key: Int) {
    val compositions: List<ControlledComposition> = synchronized(stateLock) {
        knownCompositions.toMutableList()
    }
    compositions
        .fastMapNotNull { it as? CompositionImpl }
        .fastForEach { it.invalidateGroupsWithKey(key) }
     }
}

knownCompositions

is already a MutableList, but why change MutableList to MutableList?

Is there some documentation about dynamic size layout more advanced than just the BoxWithConstraint? Typically I'd like to take in account the system font zoom to be able to decide what to show or not, or update the font size or layout accordingly.

so I’m injecting a couple of dependencies into my ViewModel like so

@HiltViewModel
class AuthenticationViewModel @Inject constructor(
    private val determineAuthStatus: DetermineAuthStatus,
    private val populateUserPrefs: PopulateUserPrefs
) : ViewModel() {

and I want to use the viewmodel in a composable like so

val viewModel : AuthenticationViewModel = hiltViewModel()

but I get that the viewmodel does not have any zero-argument constructors, I’ve already created the module for these 2 deps to be provided this composable that i’m using the viewmodel in, is started inside an Activity which I’ve set @AndroidEntryPoint on, what am I missing ?