Does anybody know the link to Compose compiler code?

Currently, in a lot of our Android apps, our ViewModels emit sealed data-class instances that closely match the UI (Views), minimizing the code in the UI (Activities, Fragments). These sealed data-classes are very easy to test in plain unit-tests, since they have no dependencies on the Android platform. My question is: Will/does Compose generate instances of classes that are very easy to unit-test as well?

I don't know if I understood 100% of model struct, are we able to create a model with immutable values and the compiler considers the model itself as an observable or only mutable fields are supported?

also, when included in the other project, compose functions generate a weird message

Stateless Functional Components (SFCs) should not be invoked, use <name_of_the_component />

I wonder what’s the intended future for two conventions of using

state

(apart from

+

operator):

var foo by +state { 0 } // property delegation to state
var (foo, setFoo) = +state { 0 } // destructuring state

Is the second-one just a React/JS gimmick because “we can” or is it really useful in some use-cases?

In our team Compose sparkled a lot of discussion. DSLs in Kotlin don’t need a compiler plugin. Why is compose different? Why is the compiler plugin necessary? Is it just there to avoid some boilerplate? (I haven’t looked at the source, yet)

It is not an alpha

Again, that's why we only provide source code

I have one question related to Continuing Explorations slide from I/O talk. Does multithreaded layout mean possibility of having multiple UI threads? 🤔

ok, I meant multiple UI threads per single app, but if it’s not about it, nevermind, thanks 🙂

I wonder how heterogeneous lists/grids will be handled though.

@romainguy I agree with other folks' suggestions to have a blog post explaining (to some degree) what

@Compose

does behind the scenes, if you have time. From the dev site:

A Compose application is made up of composable functions

Is this in a Functional Programming kind of way, alá the type

IO<T>

from FP. Or am I way off base and is it something else entirely?

I noticed the compose plugins have 1.0.0-alpha01 on the jar file?

What are the main challenges to make compose multi platform? I understand that it is not a priority for Google now but how far does the design help and can people from the outside contribute for support?

Did you look at noria project by JetBrains for reconcilation? https://github.com/JetBrains/noria-kt

I am just curious, will compose let us use custom views and add them to the view tree?

There is also a

ViewAdapter

interface that allows us to use Android widgets in Compose.

@rivu.chakraborty You shouldn't rely on the XML syntax so much, it's going away. Use the regular function call syntax instead.

Under the hood, is the composed hierarchy just represented flat via canvas paint?

Will it be possible to run Compose on a JVM (without Robolectric)? This would be very useful for speedy unit testing

I am not sure if this was mentioned at I/O but does anyone know how we would use compose when writing UI code for landscape devices or tablet/chrome os ?

Another one is - what with saving state/process death? In old framework views have a possibility to save/restore their state, how about Compose?

Do you guys have already defined how (or if) Compose will work along with MotionLayout? I ask this because both seem to be walking in opposite directions: While Compose is aiming to eliminate XML altogether, MotionLayout (wich is also awesome) is relying in describing behavior through XML in spite of Code.

I tried out compose and loved what I saw in the little time I spent with it. I have a question around the quick iteration aspect. If you take into consideration something like React Native/ Flutter, they both have some sort of hot reloading/code swapping on the fly built in to the framework, while creating declarative UIs will certainly improve the UI development cycle for Android can you guys comment on the additional infrastructure (if any) being setup to improve upon and add to the quick feedback loop so we can iterate more quickly upon the UI? _(apply changes is great and all but it’s still way behind hot reload 😅)_ Thanks for all the amazing work you guys are doing Cc @romainguy @Leland Richardson [G]

Hi, could anyone explain how @Composable annotation works under the hood? Is it creates some kind of AST tree which is returned when calling annotated function? I'm thinking maybe this concept can be used generally for "Interpreter pattern" where any actions can be written as @Composable and when AST could be traversed and interpreted later.

1. How would scrolling actions work? For example how would one tell the layout to scroll to the top? I guess you could create

onScroll

and then force developer to track the scroll position from outside? How would that work performance wise since scroll position can potentially update on every frame?

2. How would focus system work with compose?

3. How would animations work? For example dataset change animations like RecyclerView.

./studiow

failed with

Unzipping
Building compose plugin
sed: -e expression #1, char 0: no previous regular expression
./gradlew: 159: ./gradlew: $s/$/ \\/: not found
sed: -e expression #1, char 0: no previous regular expression
./gradlew: 159: ./gradlew: $s/$/ \\/: not found
Error: Could not find or load main class org.gradle.wrapper.GradleWrapperMain

Launched it manually, copied prebuilts, opened

try-compose

project. But sync is failing with (error in thread). Please, advice. 🙂

Hi all, I've been learning about Compose and found the docs make an incorrect claim that they are pure functions: https://android.googlesource.com/platform/frameworks/support/+/androidx-master-dev/compose/README.md I've sent a pull request to fix that: https://android-review.googlesource.com/c/platform/frameworks/support/+/958319 Would be great to get someone to review that.