Are their docs for sample/common usages of each composable? I know I can look at the github sample apps but I really just want a page where I can see a list of components, and then the common methods I would use on them.

Image that takes a vectorResource and a modifier no longer compiles in alpha08?

Not sure where to report this, but I’m having major problems deploying compose projects to a physical device over usb (Pixel 4a) using a new Apple Silicon Macbook Air. The phone seems to be keeping an old version, doesn’t matter if Run/Debug. Uninstalling the app is the only way for the deployment to correct launch the latest apk. This is on Android Studio Arctic Fox Canary 2 with Compose on latest alpha08. I’ve also tried with compose-samples (JetChat) and having the same problems. I have resorted to adding a dynamic buildCode to

build.gradle

which gets new deployments properly launched on the device:

def buildCode = (int)(((new Date().getTime()/1000) - 1451606400) / 10)
android {
    compileSdkVersion 30
    buildToolsVersion "30.0.2"

    defaultConfig {
        ...
        versionName "0.1.${buildCode}"
        ...
    }
}

I am not sure if this has to do with apple silicon, arctic fox, or alpha08?

How do you add inner padding in compose?

padding

modifier only seems to add margin

Has anyone faced the problem of keyboard not showing up after focusing a textfield? I'm using an

OutilnedTextField

with

savedInstanceState (<textfield-saver>) { TextFieldValue(state.text) }

Putting app in background an reopening fixes this issue. I'm not sure if I'm doing any wrong or there's a subtle issue in compose

How do I create a mini

FloatingActionButton

Is there ayway to animate an

ExtendedFloatingActionButton

into a

FloatingActionButton

?

What exactly happens when we do

collectAsState()

in it? Do I get a snapshot of snapshot of state and won't receive any further updates or will do? I've a navigation graph definition using navigation-compose and am using different viewModel for each of its screens. I'm doing

collectAsState

in the content parameter of

NavGraphBuilder.comoposable()

extension function. I want the respective Composable in the navgraph to be notified on any state changes in its associated viewModel. I checked every step in the process of mutating the state and viewModel state is working properly but the Composable is not listening to these changes and thus not being updated. How should this be achieved in general? Individual Composables listening to their own ViewModels when they're part of some navigation hierarchy like BottomNavigation ?

I just realised there's one class Called

ComposeNavigator

which is supposed to handle backstack and create destination. Where can I find the example usage of it?

hi everyone, I’m trying to upgrade a library from using alpha04 to alpha08 and I have added the following to the `build.gradle.kts`:

android {
  buildFeatures {
        compose = true
    }

    compileOptions {
        targetCompatibility = JavaVersion.VERSION_1_8
        sourceCompatibility = JavaVersion.VERSION_1_8
    }
    composeOptions {
        composeOptions.kotlinCompilerVersion = versionsProperties["version.kotlin"].toString()
        kotlinCompilerExtensionVersion = versionsProperties["version.androidx.ui"].toString()
    }
}
tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
    kotlinOptions {
        jvmTarget = "1.8"
        freeCompilerArgs = listOf("-Xallow-jvm-ir-dependencies", "-Xskip-prerelease-check")
        useIR = true
    }
}

However, I’m still getting the following error message for several classes:

Class 'androidx.compose.ui.Modifier' is compiled by a new Kotlin compiler backend and cannot be loaded by the old compiler

Hi, I have a list of composables that look like this (please see above). I have a Boolean called isDisabled, and I want to assign it to other composables when I select one of them. How can I achieve that? I have now spent two weeks trying everything I can think of, but with no success.

HI folks, I was looking for a Table composable in the Internet, I found the DataTable but seems that was removed from the Compose Material, what composable is replacing it?

Is there something equivalent to

remember()

but that launches its

calculation

in a coroutine scoped to the composable? Something like:

val myVal by remember(viewModel) {
    viewModel.someSuspendingMethod()
}

My use case is that I have a

suspend

method in a ViewModel who’s return value I need to

remember

. Sure I could make the ViewModel method a “normal” method and use

viewModelScope

to launch a coroutine, but that is going to be scoped to the ViewModel, which itself is scoped to the Activity. I want it to be scoped to the composable (so that if the composable is removed from the tree, the coroutine is canceled). I guess I could use

produceState

for this? Is that the best way?

val myVal by produceState(initialValue = "Loading...", subject = viewModel) {
   value = viewModel.someSuspendingMethod()
}

If I could convince someone here to give me a nickel every time I write

TextView("Some Text", modifier = …)

instead of

Text("Some Text", modifier = …)

… man I’d be 💰

Guys, after migration to alpha08 I got the error "Unexpected exception thrown by non-Glide code" on the screen with GlideImage from Accompanist. Has anyone had a similar problem?

Is there a way to tell is a composable running in an initial composition or a recomposition? I’m building yet another screen transition composable based on

Crossfade

and I want it not animate anything on initial composition

I have a list that I want to display, but each item in the list consists of a header and a sub list. This works, but I don't think the inner forEach loop is done correctly (this looks like it's not recycling the inner list)

LazyColumn {
    item {
        Text("MAIN HEADER")
    }
    items(mylist.sections) { section: MyClass.Section ->
        Text(section.title)
        section.subsections.forEach {
            Text(it.body)
        }
    }
}

this does not work, but it's what I expected I should do

LazyColumn {
    item {
        Text("MAIN HEADER")
    }
    items(mylist.sections) { section: MyClass.Section ->
        Text(section.title)
        item(sec.subsections) {
            Text(it.body)
        }
    }
}

compose-samples/Grid.kt at 1630f6b35ac9e25fb3cd3a64208d7c9afaaaedc5 · android/compose-samples (github.com) Layout is "undefined reference". What am I missing?

I'm using

exoplayer

with compose and for some reason the video is not getting shown. The audio starts playing as soon as the composable is rendered but video is not working. I've tried the latest version and

2.11.7

version of exoplayer and I'm currently using compose

alpha07

val context = ContextAmbient.current
val exoPlayer = remember(mediaUri) {
    SimpleExoPlayer.Builder(context)
        .build()
        .apply {
            val dataSourceFactory: DataSource.Factory = DefaultDataSourceFactory(
                context,
                Util.getUserAgent(context, context.packageName)
            )
            val source = HlsMediaSource.Factory(dataSourceFactory)
                .createMediaSource(mediaUri.toUri())
            this.prepare(source)
        }
}

Box(
    modifier = Modifier.preferredSize(244.dp)
        .padding(vertical = 24.dp, horizontal = 8.dp)
        .clip(RoundedCornerShape(12.dp)),
) {
    AndroidView(
        viewBlock = { context ->
            PlayerView(context).apply {
                layoutParams = ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT)
                useController = false
                resizeMode = RESIZE_MODE_ZOOM
                player = exoPlayer
                exoPlayer.playWhenReady = true
            }
        },
        modifier = Modifier.fillMaxSize()
    )
}

onDispose {
    exoPlayer.stop()
    exoPlayer.release()
}

Here is my implementation snippet, any help would be appreciated. Thanks!

Trying to summarize the difference between the apps of the “past” and the apps of the “future”:

Given this basic composable:

@Composable
fun FancyText(text: String) {
    val formattedText = remember(text) { computeTextFormatting(text) }
    Text(formattedText)
}

Is the use of

remember

necessary/valuable here? Seems like the only time this would get recomposed is if

text

changes, and in that case we’d want to re-compute the

formattedText

value. In other words, we’ll always re-compute the

formattedText

value, so do we even need

remember

?

Is there a way to achieve a behavior similar to the SnapshotMutationPolicy of MutableState with onCommit (or basically remember)?

Quick poll: If you could seek a

Transition

, would you prefer to seek by: 1️⃣ percentage based progress (0-1f), or 2️⃣ playtime (between 0 and total duration)?

Does anyone know how to resolve this?

This version of the Android Support plugin for IntelliJ IDEA (or Android Studio) cannot open this project, please retry with version 4.3 or newer.

I’m having this issue:

e: java.lang.IncompatibleClassChangeError: Found interface org.jetbrains.kotlin.ir.declarations.IrClass, but class was expected

at androidx.compose.compiler.plugins.kotlin.VersionChecker.check(VersionChecker.kt:65)

at androidx.compose.compiler.plugins.kotlin.ComposeIrGenerationExtension.generate(ComposeIrGenerationExtension.kt:49)

at org.jetbrains.kotlin.backend.jvm.JvmBackendFacade$doGenerateFiles$1.invoke(JvmBackendFacade.kt:72)

at org.jetbrains.kotlin.backend.jvm.JvmBackendFacade$doGenerateFiles$1.invoke(JvmBackendFacade.kt:34)

at org.jetbrains.kotlin.psi2ir.Psi2IrTranslator.generateModuleFragment(Psi2IrTranslator.kt:98)

at org.jetbrains.kotlin.backend.jvm.JvmBackendFacade.doGenerateFiles(JvmBackendFacade.kt:87)

at org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory.generateModule(JvmIrCodegenFactory.kt:40)

at org.jetbrains.kotlin.codegen.KotlinCodegenFacade.compileCorrectFiles(KotlinCodegenFacade.java:35)

at org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.generate(KotlinToJVMBytecodeCompiler.kt:616)

at org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.compileModules$cli(KotlinToJVMBytecodeCompiler.kt:203)

at org.jetbrains.kotlin.cli.jvm.K2JVMCompiler.doExecute(K2JVMCompiler.kt:164)

at org.jetbrains.kotlin.cli.jvm.K2JVMCompiler.doExecute(K2JVMCompiler.kt:51)

at org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.kt:86)

at org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.kt:44)

at org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:98)

at org.jetbrains.kotlin.incremental.IncrementalJvmCompilerRunner.runCompiler(IncrementalJvmCompilerRunner.kt:346)

at org.jetbrains.kotlin.incremental.IncrementalJvmCompilerRunner.runCompiler(IncrementalJvmCompilerRunner.kt:102)

at org.jetbrains.kotlin.incremental.IncrementalCompilerRunner.compileIncrementally(IncrementalCompilerRunner.kt:240)

at org.jetbrains.kotlin.incremental.IncrementalCompilerRunner.access$compileIncrementally(IncrementalCompilerRunner.kt:39)

at org.jetbrains.kotlin.incremental.IncrementalCompilerRunner$compile$2.invoke(IncrementalCompilerRunner.kt:81)

at org.jetbrains.kotlin.incremental.IncrementalCompilerRunner.compile(IncrementalCompilerRunner.kt:93)

at org.jetbrains.kotlin.daemon.CompileServiceImplBase.execIncrementalCompiler(CompileServiceImpl.kt:601)

at org.jetbrains.kotlin.daemon.CompileServiceImplBase.access$execIncrementalCompiler(CompileServiceImpl.kt:93)

at org.jetbrains.kotlin.daemon.CompileServiceImpl.compile(CompileServiceImpl.kt:1633)

at jdk.internal.reflect.GeneratedMethodAccessor99.invoke(Unknown Source)

at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.base/java.lang.reflect.Method.invoke(Method.java:566)

at java.rmi/sun.rmi.server.UnicastServerRef.dispatch(UnicastServerRef.java:359)

at java.rmi/sun.rmi.transport.Transport$1.run(Transport.java:200)

at java.rmi/sun.rmi.transport.Transport$1.run(Transport.java:197)

at java.base/java.security.AccessController.doPrivileged(Native Method)

at java.rmi/sun.rmi.transport.Transport.serviceCall(Transport.java:196)

at java.rmi/sun.rmi.transport.tcp.TCPTransport.handleMessages(TCPTransport.java:562)

at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run0(TCPTransport.java:796)

at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.lambda$run$0(TCPTransport.java:677)

at java.base/java.security.AccessController.doPrivileged(Native Method)

at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run(TCPTransport.java:676)

at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)

at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)

at java.base/java.lang.Thread.run(Thread.java:834)

e: java.lang.IncompatibleClassChangeError: Found interface org.jetbrains.kotlin.ir.declarations.IrClass, but class was expected

Execution failed for task ':app:compileDebugKotlin'.

> Internal compiler error. See log for more details

So my previews are not deploying anymore

Another question: why is this? 😄 I have ui-tooling, didn’t change the dependencies

1. Have Existing project that uses fragments 2. Enable compose in build.gradle via

kotlinOptions {
        jvmTarget = '1.8'
        useIR = true
    }
    buildFeatures {
        compose true
        viewBinding true
    }
    composeOptions {
        kotlinCompilerVersion '1.4.20'
        kotlinCompilerExtensionVersion '1.0.0-alpha08'
    }

...

implementation "androidx.compose.runtime:runtime:1.0.0-alpha08"

3. Everything works fine 4. Add

implementation "androidx.compose.ui:ui:1.0.0-alpha08"

5. Every fragment in my app now has a red line on the class name (but still seems to build fine). Hovering over the error says "Class 'MyFragment' is not abstract and does not implement abstract base class member public abstract fun <I : Any!, O : Any!> prepareCall" Ideas?

One aspect of the way Compose handles ViewModels appears be quite troublesome... The default ViewModel factory invokes only the parameterless constructor of any ViewModel class. Clearly most ViewModels are going to need some dependencies; so parameterless construction implies that these are being provided externally i.e. by a DI framework. But what if you don't want to use a DI framework? This is not a problem if the default factory can be reassigned to one that allows you to perform your own construction, but it can't be. Yes; it's easy to create a

ViewModelProvider.Factory

with a lambda that constructs ViewModels with parameters, there is no way to assign this as the default factory. This entails that you either have to pass the factory around your composable functions to use it e.g.

by viewModels(myFactory)

or actually override the

getDefaultViewModelFactory

method. This is convenient enough in an

Activity

but becomes more troublesome if you try to do it for a

NavHost

. In other words the API design is coercing us toward using Dependency Injection frameworks in our ViewModels, rather than just plain construction. Whether you favour DI frameworks or not; construction parameters are objectively the primary mechanism in the Kotlin language for providing dependencies to an object: this at least implies that construction parameters should remain the first and best supported mechanism, followed by others. Am I missing something here or is there a case for Google to make these API's more flexible?