Merge "Replace SharedFlow with StateFlow to fix notif height" into main

import kotlinx.coroutines.ExperimentalCoroutinesApi

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.test.TestScope

import kotlinx.coroutines.test.advanceTimeBy

import kotlinx.coroutines.test.runCurrent

import kotlinx.coroutines.test.runTest

import org.junit.Before

            var notificationCount = 10

            val calculateSpace = { space: Float, useExtraShelfSpace: Boolean -> notificationCount }

            val maxNotifications by collectLastValue(underTest.getMaxNotifications(calculateSpace))

            advanceTimeBy(50L)

            showLockscreen()

            overrideResource(R.bool.config_use_split_notification_shade, false)

            // Also updates when directly requested (as it would from NotificationStackScrollLayout)

            notificationCount = 25

            sharedNotificationContainerInteractor.notificationStackChanged()

            advanceTimeBy(50L)

            assertThat(maxNotifications).isEqualTo(25)

            // Also ensure another collection starts with the same value. As an example, folding

            // then unfolding will restart the coroutine and it must get the last value immediately.

            val newMaxNotifications by

                collectLastValue(underTest.getMaxNotifications(calculateSpace))

            advanceTimeBy(50L)

            assertThat(newMaxNotifications).isEqualTo(25)

        }

            var notificationCount = 10

            val calculateSpace = { space: Float, useExtraShelfSpace: Boolean -> notificationCount }

            val maxNotifications by collectLastValue(underTest.getMaxNotifications(calculateSpace))

            advanceTimeBy(50L)

            showLockscreen()

            overrideResource(R.bool.config_use_split_notification_shade, false)

        testScope.runTest {

            val calculateSpace = { space: Float, useExtraShelfSpace: Boolean -> 10 }

            val maxNotifications by collectLastValue(underTest.getMaxNotifications(calculateSpace))

            advanceTimeBy(50L)

            // Show lockscreen with shade expanded

            showLockscreenWithShadeExpanded()

import dagger.Lazy

import javax.inject.Inject

import kotlinx.coroutines.flow.Flow

import kotlinx.coroutines.flow.MutableSharedFlow

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.asSharedFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.flow.combine

import kotlinx.coroutines.flow.debounce

import kotlinx.coroutines.flow.distinctUntilChanged

import kotlinx.coroutines.flow.map

import kotlinx.coroutines.flow.onStart

    private val _topPosition = MutableStateFlow(0f)

    val topPosition = _topPosition.asStateFlow()

    private val _notificationStackChanged = MutableSharedFlow<Unit>(extraBufferCapacity = 1)

    private val _notificationStackChanged = MutableStateFlow(0L)

    /** An internal modification was made to notifications */

    val notificationStackChanged = _notificationStackChanged.asSharedFlow()

    val notificationStackChanged = _notificationStackChanged.debounce(20L)

    val configurationBasedDimensions: Flow<ConfigurationBasedDimensions> =

        configurationRepository.onAnyConfigurationChange

    /** An internal modification was made to notifications */

    fun notificationStackChanged() {

        _notificationStackChanged.tryEmit(Unit)

        _notificationStackChanged.value = _notificationStackChanged.value + 1

    }

    data class ConfigurationBasedDimensions(

                showUnlimitedNotifications,

                shadeInteractor.isUserInteracting,

                availableHeight,

                interactor.notificationStackChanged.onStart { emit(Unit) },

                interactor.notificationStackChanged,

                interactor.useExtraShelfSpace,

            ) { flows ->

                val showLimitedNotifications = flows[0] as Boolean