Will

AndroidView

recreate view when

LocalContext.current

changed?

LocalContext

is

StaticCompositionLocal

which means that if it changes, it should recompose the whole composition tree.

Unlike compositionLocalOf, reads of a staticCompositionLocalOf are not tracked by the composer and changing the value provided in the CompositionLocalProvider call will cause the entirety of the content to be recomposed instead of just the places where in the composition the local value is used.

Thanks, Filip. So, the answer is no, since recomposition doesn’t trigger

AndroidView

to invoke its

factory

lambda again to recreate view. Am I right?

I think that the answer is yes. If I understand it correctly, the whole UI tree including the

AndroidView

is destroyed and created again.

Well, the recomposition doesn’t destroy and recreate the whole tree. It just re-execute the root composable function to update the tree.

I mean yeah but I bet the

AndroidView

depends on the context so if the context changes (and that is a big if), it should be recreated. Either way I would think that this is something the creators of Compose and more specifically

AndroidView

thought of and you should not have to think about things like this. Or do you have some specific use case that relies on this behavior?

If it does’t recreate the view, the previous context will be leaked. I believe that the Compose team can guarantee the correctness. I’m just curious about how the recreation is triggered (if it does recreate). But I can’t figure it out with the source code (maybe I missed something).

I'm struggling to think of a case where *re*composition can occur with a different Context. If it could, then the View system would be similarly broken.

I’ve verified. The answer is no. Here is my code:

val localContext = LocalContext.current
var context by remember { mutableStateOf(localContext) }
CompositionLocalProvider(
    LocalContext provides context
) {
    Log.d("AndroidView", "compose: context - ${LocalContext.current}")
    AndroidView(factory = { context ->
        TextView(context).apply {
            Log.d("AndroidView", "create view: ${this.hashCode()}")
        }
    }) {
        Log.d("AndroidView", "update view: ${it.hashCode()}")
    }
}
LaunchedEffect(key1 = Unit) {
    delay(3000)
    context = ContextWrapper(context)
}

And log is:

compose: context - sample.MainActivity@da29b84
create view: 162893151
update view: 162893151
compose: context - android.content.ContextWrapper@d588329

In Compose UI, the Context is what hosts ComposeView, which in turn runs the composition. If Context was able to change, then the View class hierarchy would be irreperably broken as it contains references to the containing Context all over the place. That said, there is no mechanism to enforce this that's exposed in the compose-ui API, so you'll have to either: trust that

LocalContext

is an immutable property of the composition, or; structure your code to make no assumptions about the runtime value of

LocalContext

. In practice, both stances are the same, because

staticCompositionLocalOf

will trigger a recomposition of everything, as it's set within

setContent

on Android; therefore you can't really avoid being recomposed.

Thanks, Tad. Your answer clarifies

LocalContext

for me.