whats a rough timeline on this? a year?

Isn't Compose's Positional Memoization is essentially the same as Incremental DOM? I can see a lot of similarities

Hey, I'm getting started with compose. Can anyone guide me to good getting started guide or blogs. Also learning more about reacts declarative ui will help in better understanding in compose?.. will state and event management like thing will be required for Android too now?

At risk of this channel just becoming shameless self-promotion… the recording of my Chain React talk about compose just came out. Some folks here asked me to post it, so here it is!

So with compose, would it make sense to architect your data flow and manage state using redux maybe with the help of https://github.com/ReKotlin/ReKotlin ?

i also haven’t used the above library, but pretty much all redux-like libraries will be able to easily interop with compose. Looking at the readme, and targeting current Compose APIs (which are subject to change), you could easily interop with ReKotlin like so:

// normal API to create a store based on readme example
val mainStore = Store(
     reducer = ::counterReducer,
     state = null
)

// effect-based API to select/subscribe to store in composition
fun <TSlice, TState> Store<TState>.select(selector: (TState) -> TSlice) = effectOf<TSlice> {
  val result = +state { selector(state) }
  +onCommit(selector) {
    val observer = StoreSubscriber<TSlice> { result.value = it }
    subscribe(observer, selector)
    onDispose {
      unsubscribe(observer)
    }
  }
  result.value
}

// usage
@Composable fun SomeView() {
  val count = +mainStore.select { it.counter }
  Text("Count: $count")
}

yes, quite a bit of lifecycle discussion. It's my goal to have pure-compose activities handle their own config changes, i.e. not tear down and recreate the activity. With a reactive system it's redundant. In many ways you can think of Android's activity recreation as a very coarse-grained reactive rebuild of a UI and compose can do it granularly.

breakpoints should work without anything special. what logging do you want to enable?

Are there particular issues with using Compose in a fragment? This code builds and runs fine, though admittedly it does not do much:

class SampleRosterFragment : Fragment() {
    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View =
        inflater.inflate(R.layout.empty_frame, container, false)

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        (view as ViewGroup).setContent {
            Padding(10.dp) {
                
            }
        }
    }
}

This code causes the IDE and Gradle to go ballistic, with inscrutable error messages:

class SampleRosterFragment : Fragment() {
    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View =
        inflater.inflate(R.layout.empty_frame, container, false)

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        (view as ViewGroup).setContent {
            MaterialTheme {
                Padding(10.dp) {

                }
            }
        }
    }
}

Yet that same

MaterialTheme

construction works fine from an activity. I notice that the demos seem activity-centric, though I'm not certain if that is due to current Compose limitations or is tied to other concerns for how you are using those activities.

I have a question about the general philosophy moving forward with compose. Is the the thought that in the future we'll typically move away from activities and fragments and just have compose views all the way down? Or is the plan to integrate compose and activities/fragments to retain some of the current approaches to navigation.

Hi all. I’ve been Googling around but can’t seem to find an answer for this. Does JetPack compose support (or planning to support) resource qualifiers? Something that is currently easy to do in Android is supporting multiple configurations e.g. density based, RTL layouts, localizations etc. Powered by DataBinding null-aware inflation, this made supporting all this configurations quite trivial to implement. If it wasn’t supported, maybe something of the below (haven’t look thru the Compose code yet) would work?:

@Qualifiers("sw600dp")
@Composable
fun someView(){
   ...
}

Or maybe just pass in the current qualifiers to the composable function? If I got off the wrong starting point, please enlighten me. Thanks!

Hi all. Is Compose Android-only ui library or can we use it for the kotlin multiplatform? Since this library will be delivered separately from Android, will it be possible to use it without the android framework?

Hi, Does Compose UI have a first-class API for user input like multi-touch gestures, mouse/touchpad input (think Chromebooks), keyboards, and arbitrary input soures? Or will we need to use platform API? Or maybe it's planned?

If found the following comment in Compose codebase:

// onConfigurationChange is the correct hook to update configuration, however it is

// possible that the configuration object itself may come from a wrapped

// context / themed activity, and may not actually reflect the system. So instead we

// use this hook to grab the applicationContext's configuration, which accurately

// reflects the state of the application / system.

(from https://android.googlesource.com/platform/frameworks/support/+/androidx-master-dev/ui/ui-framework/src/main/java/androidx/ui/core/Wrapper.kt#170) and I'm concerned it would break the usage of

Context.createConfigurationContext()

usually used when you want to change the language to be different from the default one in the system, or use an app local custom configuration for other purposes. Why not use the configuration from the given context instead?

Should the automatic recomposition feature of

@Model

be working in the current Compose code? I created this based on the

@Model

KDoc:

@Model
    data class AgreementViewState(var terms: Boolean = true, var privacy: Boolean = false) {
        val canProceed = terms && privacy
    }

    @Composable
    private fun Agreement() {
        Padding(8.dp) {
            val viewState = +model { AgreementViewState() }

            Column(mainAxisAlignment = MainAxisAlignment.Start, crossAxisAlignment = CrossAxisAlignment.Start) {
                Row(mainAxisAlignment = MainAxisAlignment.Start) {
                    Checkbox(
                        checked = viewState.terms,
                        onCheckedChange = { viewState.terms = it }
                    )
                    Text(text = "I agree to the terms and conditions")
                }
                Row(mainAxisAlignment = MainAxisAlignment.Start) {
                    Checkbox(
                        checked = viewState.privacy,
                        onCheckedChange = { viewState.privacy = it }
                    )
                    Text(text = "I agree to the privacy policy")
                }
                Text(text = if (viewState.canProceed) "You may proceed" else "Please indicate your agreement")
            }
        }
    }

The initial state works (the top

Checkbox

is checked). And via logging I can confirm that my

onCheckedChange

lambdas are being called. However, the UI is not being recomposed as I update the

AgreementViewState

, so the checkboxes and text remain fixed. By contrast, this works with automatic recomposition as I update the `checkboxState`:

@Composable
    private fun SimpleCheckbox() {
        Padding(8.dp) {
            val checkboxState = +state { true }

            Checkbox(
                checked = checkboxState.value,
                onCheckedChange = { checkboxState.value = it }
            )
        }
    }

I'm trying to determine if there's something that I'm doing wrong or if this is just a current limitation. Thanks!

Any updates on coroutines working with compose? Getting “An operation is not implemented: not implemented while generating code for”

And what about SAM conversions inside effect hooks (not sure how these constructs called properly)?

@Composable
fun foo() {
    +onActive {
        (0..10).maxWith(Comparator<Int> { a, b -> a.compareTo(b) })
    }
}

this code above throws long compilation error but this code below runs fine

@Composable
fun foo() {
    +onActive {
        (0..10).maxWith(object : Comparator<Int> {
            override fun compare(a: Int, b: Int): Int {
                return a.compareTo(b)
            }
        })
    }
}

Yesterday I was playing around with Jetpack Compose and I found out there’s a new

Compose Activity

from the

New File > Activity

menu. This creates some files but the code inside of them is broken. any clue? 🙂

What does this:

Caused by: java.lang.IllegalStateException: Composition requires an active composition context

mean? What are the possible causes?

@Mark Murphy This kind of widgets will very likely use child windows

How will compose ui testing look like? Do you plan to improve Espresso or you will create brand-new testing framework similar to Flutter Driver?

On Friday, we merged in the IR rebase, which means that a whole bunch of Kotlin features which previously didn't work are now working! The backend IR is still a WIP, so not everything is working, but it should be better than before. For example, SAM types (passing lambda where a single method interface is accepted) are now working! Feel free to do a repo sync and try it out!

Hi. This is my first post. I would like to know how to create a new activity for trying Jetpack Compose. I have already downloaded ASOP in my computer. I tried creating a new

Compose Activity

via

File -> New -> Activity

on

ui-demos

folder. But some extra xml files and codes added in

build.gradle

, so that the project could not build at all.

I'm also working on a little game, actually 3 mini games, written in Jetpack Compose🎉. I don't have slides but the source code: https://github.com/SimonSchubert/Braincup It's almost ready to be shipped into production(joking😬) but I get an ANR in 1 minigame and I can't figure out why. Because the other 2 games run fine and I don't see what I'm doing significant different. Stacktrace and class are in the comments. Maybe someone has a hint or feedback in general.

Can anyone tell why this piece of code is throwing the exception?

Hello, trying to achieve a Todo List in Compose, however, when I create a

@Model

class which has a list, adding elements to that list don’t trigger the drawing of the model on the screen. In order to have it working I added a

counter

to that model class. Increasing that

counter

whenever I add something to the list triggers the drawing of the model on the screen. (https://gist.github.com/lnicolet/039d2fe76e19e859582e32625ac411e7, https://gist.github.com/lnicolet/cb49c5a4021efc3b784bf95ec5755321). Working and not working examples in the links. Is there a different way to have it working with

lists

?

What's the best way of keeping up to date on changes to Compose? I'm taking the Ray Wenderlich tutorial series on Compose and have run into a case where a component (CraneWrapper) is no longer available.

https://android-review.googlesource.com/c/platform/frameworks/support/+/1112008 Oh boy, we're finally getting near to a release outside of androidx, awesome.