Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 86a125e1 authored by Jordan Demeulenaere's avatar Jordan Demeulenaere
Browse files

Prevent recomposition every frame in TileLabel

Bug: 413634246
Test: Manual, compared traces before & after
Flag: EXEMPT performance fix
Change-Id: Id2b32f1a96a6909c4ac1aa072799409fb3835c47
parent 75abf492
Loading
Loading
Loading
Loading
+41 −25
Original line number Diff line number Diff line
@@ -57,6 +57,8 @@ import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.State
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.remember
@@ -688,20 +690,26 @@ constructor(
            ) {
                val Tiles =
                    @Composable {
                        // When always compose is false, this will always be true, and we'll be
                        // listening whenever this is composed. When always compose is true, we
                        // listen if we are visible and not fully expanded
                        val isListening: () -> Boolean =
                            if (alwaysCompose) {
                                remember(viewModel) {
                                        derivedStateOf {
                                            viewModel.isQsVisibleAndAnyShadeExpanded &&
                                                viewModel.expansionState.progress < 1f &&
                                                !viewModel.isEditing
                                        }
                                    }
                                    .let { state -> { state.value } }
                            } else {
                                { true }
                            }

                        QuickQuickSettings(
                            viewModel = viewModel.quickQuickSettingsViewModel,
                            listening = {
                                /*
                                 *  When always compose is false, this will always be true, and we'll be
                                 *  listening whenever this is composed.
                                 *  When always compose is true, we listen if we are visible and not
                                 *  fully expanded
                                 */
                                !alwaysCompose ||
                                    (viewModel.isQsVisibleAndAnyShadeExpanded &&
                                        viewModel.expansionState.progress < 1f &&
                                        !viewModel.isEditing)
                            },
                            listening = isListening,
                        )
                    }
                val Media =
@@ -834,22 +842,30 @@ constructor(
                            @Composable {
                                Box {
                                    GridAnchor()

                                    // When always compose is false, this will always be true, and
                                    // we'll be listening whenever this is composed. When always
                                    // compose is true, we look a the second condition and we'll
                                    // listen if QS is visible AND we are not fully collapsed.
                                    val isListening: () -> Boolean =
                                        if (alwaysCompose) {
                                            remember(viewModel) {
                                                    derivedStateOf {
                                                        viewModel.isQsVisibleAndAnyShadeExpanded &&
                                                            viewModel.expansionState.progress >
                                                                0f &&
                                                            !viewModel.isEditing
                                                    }
                                                }
                                                .let { state -> { state.value } }
                                        } else {
                                            { true }
                                        }

                                    TileGrid(
                                        viewModel = containerViewModel.tileGridViewModel,
                                        modifier = Modifier.fillMaxWidth(),
                                        listening = {
                                            /*
                                             *  When always compose is false, this will always be true,
                                             *  and we'll be listening whenever this is composed.
                                             *  When always compose is true, we look a the second
                                             *  condition and we'll listen if QS is visible AND we are
                                             *  not fully collapsed.
                                             */
                                            !alwaysCompose ||
                                                (viewModel.isQsVisibleAndAnyShadeExpanded &&
                                                    viewModel.expansionState.progress > 0f &&
                                                    !viewModel.isEditing)
                                        },
                                        listening = isListening,
                                    )
                                }
                            }