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

Commit 920b161b authored by Michal Brzezinski's avatar Michal Brzezinski
Browse files

Extracting display switch logic to FoldableDisplaySwitchTrackingInteractor 

First step of implementing tracking unfolding velocity - we will use the same logic for tracking display switch so it's worth extracting it to separate class that can be used in both places.
For now test remains the same (to make sure everything works as before) but in the follow-up I'll split it in two separate test classes.

Bug: 405128401
Flag: EXEMPT refactor with keeping test the same
Test: DisplaySwitchLatencyTrackerTest
Change-Id: Ic1d4e7022974a6eabb9af1960fe89ed699bd5dfd
parent 2c1ffb4a

packages/SystemUI/multivalentTests/src/com/android/systemui/unfold/DisplaySwitchLatencyTrackerTest.kt

+39 −14
Original line number Diff line number Diff line
@@ -47,13 +47,14 @@ import com.android.systemui.power.shared.model.ScreenPowerState.SCREEN_ON 
import com.android.systemui.shared.system.SysUiStatsLog

import com.android.systemui.statusbar.policy.FakeConfigurationController

import com.android.systemui.testKosmos

import com.android.systemui.unfold.DisplaySwitchLatencyTracker.Companion.COOL_DOWN_DURATION

import com.android.systemui.unfold.DisplaySwitchLatencyTracker.Companion.FOLDABLE_DEVICE_STATE_CLOSED

import com.android.systemui.unfold.DisplaySwitchLatencyTracker.Companion.FOLDABLE_DEVICE_STATE_HALF_OPEN

import com.android.systemui.unfold.DisplaySwitchLatencyTracker.Companion.SCREEN_EVENT_TIMEOUT

import com.android.systemui.unfold.DisplaySwitchLatencyTracker.DisplaySwitchLatencyEvent

import com.android.systemui.unfold.data.repository.ScreenTimeoutPolicyRepository

import com.android.systemui.unfold.data.repository.UnfoldTransitionRepositoryImpl

import com.android.systemui.unfold.domain.interactor.FoldableDisplaySwitchTrackingInteractor

import com.android.systemui.unfold.domain.interactor.FoldableDisplaySwitchTrackingInteractor.Companion.COOL_DOWN_DURATION

import com.android.systemui.unfold.domain.interactor.FoldableDisplaySwitchTrackingInteractor.Companion.SCREEN_EVENT_TIMEOUT

import com.android.systemui.unfold.domain.interactor.UnfoldTransitionInteractor

import com.android.systemui.unfoldedDeviceState

import com.android.systemui.util.animation.data.repository.fakeAnimationStatusRepository
@@ -62,7 +63,6 @@ import com.android.systemui.util.time.FakeSystemClock 
import com.google.common.truth.Truth.assertThat

import java.util.Optional

import kotlin.time.Duration.Companion.milliseconds

import kotlinx.coroutines.asExecutor

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.test.StandardTestDispatcher

import kotlinx.coroutines.test.TestDispatcher
@@ -93,7 +93,7 @@ class DisplaySwitchLatencyTrackerTest : SysuiTestCase() { 
    private val kosmos = testKosmos()

    private val mockContext = mock<Context>()

    private val resources = mock<Resources>()

    private val foldStateRepository = kosmos.fakeDeviceStateRepository

    private val deviceStateRepository = kosmos.fakeDeviceStateRepository

    private val powerInteractor = PowerInteractorFactory.create().powerInteractor

    private val animationStatusRepository = kosmos.fakeAnimationStatusRepository

    private val keyguardInteractor = mock<KeyguardInteractor>()
@@ -143,20 +143,29 @@ class DisplaySwitchLatencyTrackerTest : SysuiTestCase() { 
        animationStatusRepository.onAnimationStatusChanged(true)

        powerInteractor.setAwakeForTest()

        powerInteractor.setScreenPowerState(SCREEN_ON)



        val displaySwitchInteractor =

            FoldableDisplaySwitchTrackingInteractor(

                deviceStateRepository,

                powerInteractor,

                unfoldTransitionInteractor,

                animationStatusRepository,

                keyguardInteractor,

                systemClock,

                testScope.backgroundScope,

            )

        displaySwitchInteractor.start()

        displaySwitchLatencyTracker =

            DisplaySwitchLatencyTracker(

                mockContext,

                foldStateRepository,

                powerInteractor,

                screenTimeoutPolicyRepository,

                unfoldTransitionInteractor,

                animationStatusRepository,

                keyguardInteractor,

                testDispatcher.asExecutor(),

                testScope.backgroundScope,

                displaySwitchLatencyLogger,

                systemClock,

                deviceStateManager,

                displaySwitchInteractor,

                latencyTracker,

            )

    }
@@ -196,20 +205,28 @@ class DisplaySwitchLatencyTrackerTest : SysuiTestCase() { 
                    UnfoldTransitionRepositoryImpl(Optional.empty()),

                    configurationInteractor,

                )

            val displaySwitchInteractor =

                FoldableDisplaySwitchTrackingInteractor(

                    deviceStateRepository,

                    powerInteractor,

                    unfoldTransitionInteractorWithEmptyProgressProvider,

                    animationStatusRepository,

                    keyguardInteractor,

                    systemClock,

                    testScope.backgroundScope,

                )

            displaySwitchInteractor.start()

            displaySwitchLatencyTracker =

                DisplaySwitchLatencyTracker(

                    mockContext,

                    foldStateRepository,

                    powerInteractor,

                    screenTimeoutPolicyRepository,

                    unfoldTransitionInteractorWithEmptyProgressProvider,

                    animationStatusRepository,

                    keyguardInteractor,

                    testDispatcher.asExecutor(),

                    testScope.backgroundScope,

                    displaySwitchLatencyLogger,

                    systemClock,

                    deviceStateManager,

                    displaySwitchInteractor,

                    latencyTracker,

                )
@@ -467,13 +484,14 @@ class DisplaySwitchLatencyTrackerTest : SysuiTestCase() { 
    }



    @Test

    fun displaySwitchInterrupted_cancelsTrackingWhenNewDeviceStateEmitted() {

    fun displaySwitchInterrupted_newDeviceState_trackingNotSent() {

        testScope.runTest {

            startInFoldedState(displaySwitchLatencyTracker)



            startUnfolding()

            startFolding()

            finishFolding()

            waitForCorruptedStateToPass()



            verify(latencyTracker).onActionCancel(ACTION_SWITCH_DISPLAY_UNFOLD)

            verify(latencyTracker, never()).onActionEnd(ACTION_SWITCH_DISPLAY_UNFOLD)
@@ -491,6 +509,7 @@ class DisplaySwitchLatencyTrackerTest : SysuiTestCase() { 
            startFolding()

            startUnfolding()

            finishUnfolding()

            waitForCorruptedStateToPass()



            verify(latencyTracker).onActionCancel(ACTION_SWITCH_DISPLAY_UNFOLD)

            verify(latencyTracker, never()).onActionEnd(ACTION_SWITCH_DISPLAY_UNFOLD)
@@ -621,6 +640,7 @@ class DisplaySwitchLatencyTrackerTest : SysuiTestCase() { 
            startInFoldedState(displaySwitchLatencyTracker)



            startUnfolding()

            systemClock.advanceTime(SCREEN_EVENT_TIMEOUT.inWholeMilliseconds)

            advanceTimeBy(SCREEN_EVENT_TIMEOUT + 10.milliseconds)

            finishUnfolding()
@@ -747,7 +767,12 @@ class DisplaySwitchLatencyTrackerTest : SysuiTestCase() { 
        runCurrent()

    }



    private fun TestScope.waitForCorruptedStateToPass() {

        // extra buffer time so corrupted state is finished

        advanceTimeBy(COOL_DOWN_DURATION.plus(10.milliseconds))

    }



    private suspend fun setDeviceState(state: DeviceState) {

        foldStateRepository.emit(state)

        deviceStateRepository.emit(state)

    }

}

packages/SystemUI/shared/src/com/android/systemui/unfold/system/SystemUnfoldSharedModule.kt

+25 −12
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ import android.os.Handler 
import android.os.HandlerThread

import android.os.Looper

import android.os.Process

import com.android.systemui.dagger.qualifiers.Application

import com.android.systemui.dagger.qualifiers.Main

import com.android.systemui.dagger.qualifiers.UiBackground

import com.android.systemui.unfold.config.ResourceUnfoldTransitionConfig
@@ -25,6 +26,7 @@ import com.android.systemui.unfold.config.UnfoldTransitionConfig 
import com.android.systemui.unfold.dagger.UnfoldBg

import com.android.systemui.unfold.dagger.UnfoldMain

import com.android.systemui.unfold.dagger.UnfoldSingleThreadBg

import com.android.systemui.unfold.dagger.UnfoldTracking

import com.android.systemui.unfold.updates.FoldProvider

import com.android.systemui.unfold.util.CurrentActivityTypeProvider

import dagger.Binds
@@ -33,7 +35,10 @@ import dagger.Provides 
import java.util.concurrent.Executor

import javax.inject.Singleton

import kotlinx.coroutines.CoroutineDispatcher

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.android.asCoroutineDispatcher

import kotlinx.coroutines.asCoroutineDispatcher

import kotlinx.coroutines.plus



/**

 * Dagger module with system-only dependencies for the unfold animation. The code that is used to
@@ -45,25 +50,20 @@ import kotlinx.coroutines.android.asCoroutineDispatcher 
abstract class SystemUnfoldSharedModule {



    @Binds

    abstract fun activityTypeProvider(executor: ActivityManagerActivityTypeProvider):

            CurrentActivityTypeProvider

    abstract fun activityTypeProvider(

        executor: ActivityManagerActivityTypeProvider

    ): CurrentActivityTypeProvider



    @Binds

    abstract fun config(config: ResourceUnfoldTransitionConfig): UnfoldTransitionConfig

    @Binds abstract fun config(config: ResourceUnfoldTransitionConfig): UnfoldTransitionConfig



    @Binds

    abstract fun foldState(provider: DeviceStateManagerFoldProvider): FoldProvider

    @Binds abstract fun foldState(provider: DeviceStateManagerFoldProvider): FoldProvider



    @Binds

    abstract fun deviceStateRepository(provider: DeviceStateRepositoryImpl): DeviceStateRepository



    @Binds

    @UnfoldMain

    abstract fun mainExecutor(@Main executor: Executor): Executor

    @Binds @UnfoldMain abstract fun mainExecutor(@Main executor: Executor): Executor



    @Binds

    @UnfoldMain

    abstract fun mainHandler(@Main handler: Handler): Handler

    @Binds @UnfoldMain abstract fun mainHandler(@Main handler: Handler): Handler



    @Binds

    @UnfoldSingleThreadBg
@@ -92,5 +92,18 @@ abstract class SystemUnfoldSharedModule { 
                .apply { start() }

                .looper

        }



        @Provides

        @UnfoldTracking

        @Singleton

        fun unfoldTrackingContext(

            @UnfoldSingleThreadBg singleThreadBgExecutor: Executor,

            @Application applicationScope: CoroutineScope,

        ): CoroutineScope {

            // tracking depends on being executed on a single thread so when changing it, ensure all

            // consumers are not accessing shared state

            val backgroundDispatcher = singleThreadBgExecutor.asCoroutineDispatcher()

            return applicationScope + backgroundDispatcher

        }

    }

}

packages/SystemUI/src/com/android/systemui/unfold/DisplaySwitchLatencyTracker.kt

+132 −201

File changed.

Preview size limit exceeded, changes collapsed.

packages/SystemUI/src/com/android/systemui/unfold/SysUIUnfoldModule.kt

+10 −5
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ import com.android.systemui.shade.NotificationPanelUnfoldAnimationController 
import com.android.systemui.statusbar.phone.StatusBarMoveFromCenterAnimationController

import com.android.systemui.unfold.dagger.NaturalRotation

import com.android.systemui.unfold.dagger.UnfoldBg

import com.android.systemui.unfold.domain.interactor.DisplaySwitchTrackingInteractor

import com.android.systemui.unfold.domain.interactor.FoldableDisplaySwitchTrackingInteractor

import com.android.systemui.unfold.util.NaturalRotationUnfoldProgressProvider

import com.android.systemui.unfold.util.ScopedUnfoldTransitionProgressProvider

import com.android.systemui.unfold.util.UnfoldKeyguardVisibilityManager
@@ -56,9 +58,7 @@ import javax.inject.Scope 
@Module(subcomponents = [SysUIUnfoldComponent::class])

class SysUIUnfoldModule {



    /**

     * Qualifier for dependencies bound in [com.android.systemui.unfold.SysUIUnfoldModule]

     */

    /** Qualifier for dependencies bound in [com.android.systemui.unfold.SysUIUnfoldModule] */

    @Qualifier

    @MustBeDocumented

    @Retention(AnnotationRetention.RUNTIME)
@@ -72,7 +72,7 @@ class SysUIUnfoldModule { 
        rotationProvider: Optional<NaturalRotationUnfoldProgressProvider>,

        @Named(UNFOLD_STATUS_BAR) scopedProvider: Optional<ScopedUnfoldTransitionProgressProvider>,

        @UnfoldBg bgProvider: Optional<UnfoldTransitionProgressProvider>,

        factory: SysUIUnfoldComponent.Factory

        factory: SysUIUnfoldComponent.Factory,

    ): Optional<SysUIUnfoldComponent> {

        val p1 = provider.getOrNull()

        val p2 = rotationProvider.getOrNull()
@@ -92,6 +92,11 @@ interface SysUIUnfoldStartableModule { 
    @IntoMap

    @ClassKey(UnfoldInitializationStartable::class)

    fun bindsUnfoldInitializationStartable(impl: UnfoldInitializationStartable): CoreStartable



    @Binds

    @IntoMap

    @ClassKey(DisplaySwitchTrackingInteractor::class)

    fun bindsDisplaySwitchTracker(impl: FoldableDisplaySwitchTrackingInteractor): CoreStartable

}



@Module
@@ -128,7 +133,7 @@ interface SysUIUnfoldComponent { 
            @BindsInstance p1: UnfoldTransitionProgressProvider,

            @BindsInstance p2: NaturalRotationUnfoldProgressProvider,

            @BindsInstance p3: ScopedUnfoldTransitionProgressProvider,

            @BindsInstance @UnfoldBg p4: UnfoldTransitionProgressProvider

            @BindsInstance @UnfoldBg p4: UnfoldTransitionProgressProvider,

        ): SysUIUnfoldComponent

    }

packages/SystemUI/src/com/android/systemui/unfold/domain/interactor/FoldableDisplaySwitchTrackingInteractor.kt

0 → 100644
+238 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2025 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.systemui.unfold.domain.interactor



import android.os.Build

import android.util.Log

import androidx.annotation.VisibleForTesting

import com.android.app.tracing.TraceUtils.traceAsync

import com.android.app.tracing.instantForTrack

import com.android.systemui.CoreStartable

import com.android.systemui.dagger.SysUISingleton

import com.android.systemui.display.data.repository.DeviceStateRepository

import com.android.systemui.display.data.repository.DeviceStateRepository.DeviceState

import com.android.systemui.keyguard.domain.interactor.KeyguardInteractor

import com.android.systemui.power.domain.interactor.PowerInteractor

import com.android.systemui.power.shared.model.ScreenPowerState

import com.android.systemui.power.shared.model.WakefulnessModel

import com.android.systemui.power.shared.model.WakefulnessState

import com.android.systemui.unfold.dagger.UnfoldTracking

import com.android.systemui.unfold.data.repository.UnfoldTransitionStatus.TransitionStarted

import com.android.systemui.unfold.domain.interactor.DisplaySwitchState.Corrupted

import com.android.systemui.unfold.domain.interactor.DisplaySwitchState.Idle

import com.android.systemui.util.animation.data.repository.AnimationStatusRepository

import com.android.systemui.util.kotlin.pairwise

import com.android.systemui.util.kotlin.race

import com.android.systemui.util.time.SystemClock

import javax.inject.Inject

import kotlin.coroutines.cancellation.CancellationException

import kotlin.time.Duration.Companion.seconds

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.FlowPreview

import kotlinx.coroutines.TimeoutCancellationException

import kotlinx.coroutines.flow.Flow

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.collectLatest

import kotlinx.coroutines.flow.drop

import kotlinx.coroutines.flow.filter

import kotlinx.coroutines.flow.first

import kotlinx.coroutines.flow.merge

import kotlinx.coroutines.flow.timeout

import kotlinx.coroutines.launch

import kotlinx.coroutines.withTimeout



interface DisplaySwitchTrackingInteractor {

    /**

     * Emits latest [DisplaySwitchState] with a guarantee it doesn't emit the same class of state

     * twice in a row.

     */

    val displaySwitchState: StateFlow<DisplaySwitchState>

}



sealed interface DisplaySwitchState {

    val newDeviceState: DeviceState



    /**

     * Displays are in a stable state aka not in the process of switching. If we couldn't track

     * display switch properly because end event never arrived within [SCREEN_EVENT_TIMEOUT],

     * [timedOut] is set to true.

     */

    data class Idle(override val newDeviceState: DeviceState, val timedOut: Boolean = false) :

        DisplaySwitchState



    /** Displays are currently switching. This state can only come directly after [Idle] state. */

    data class Switching(override val newDeviceState: DeviceState) : DisplaySwitchState



    /**

     * Switching displays happened multiple times before [Idle] state could settle. This state will

     * hold until no new display switch related events are sent within [COOL_DOWN_DURATION] window.

     * This event can only happen directly after [Switching] state and is always directly followed

     * by [Idle] state.

     */

    data class Corrupted(override val newDeviceState: DeviceState) : DisplaySwitchState



    /** Missing data about device state, should happen only when class is initialized. */

    data object Unknown : DisplaySwitchState {

        override val newDeviceState: DeviceState = DeviceState.UNKNOWN

    }

}



/**

 * Contains data about current state of display switch on foldable device which can be one of

 * [DisplaySwitchState]. [displaySwitchState] emits only states that we're sure are legit changes,

 * compared to super quick toggling between the states caused by Hall sensor misfiring or user doing

 * something very creative. Those kind of changes cause [DisplaySwitchState.CORRUPTED] to be

 * emitted.

 *

 * You need to call [start] for [displaySwitchState] to start emitting state changes.

 */

@SysUISingleton

class FoldableDisplaySwitchTrackingInteractor

@Inject

constructor(

    private val deviceStateRepository: DeviceStateRepository,

    private val powerInteractor: PowerInteractor,

    private val unfoldTransitionInteractor: UnfoldTransitionInteractor,

    private val animationStatusRepository: AnimationStatusRepository,

    private val keyguardInteractor: KeyguardInteractor,

    private val systemClock: SystemClock,

    @UnfoldTracking private val scope: CoroutineScope,

) : DisplaySwitchTrackingInteractor, CoreStartable {



    private val _displaySwitchState =

        MutableStateFlow<DisplaySwitchState>(DisplaySwitchState.Unknown)



    override val displaySwitchState: StateFlow<DisplaySwitchState> = _displaySwitchState



    private val displaySwitchStarted =

        deviceStateRepository.state.pairwise().filter {

            // React only when the foldable device is

            // folding(UNFOLDED/HALF_FOLDED -> FOLDED) or unfolding(FOLDED -> HALF_FOLD/UNFOLDED)

            foldableDeviceState ->

            foldableDeviceState.previousValue == DeviceState.FOLDED ||

                foldableDeviceState.newValue == DeviceState.FOLDED

        }



    private val startOrEndEvent: Flow<Any> = merge(displaySwitchStarted, anyEndEventFlow())



    private var isCoolingDown = false



    override fun start() {

        scope.launch {

            _displaySwitchState.value =

                Idle(deviceStateRepository.state.first { it != DeviceState.UNKNOWN })

            displaySwitchStarted.collectLatest { (previousState, newState) ->

                if (isCoolingDown) return@collectLatest

                log { "received previousState=$previousState, newState=$newState" }

                try {

                    _displaySwitchState.value = DisplaySwitchState.Switching(newState)

                    withTimeout(SCREEN_EVENT_TIMEOUT) {

                        traceAsync(TAG, "displaySwitch") { waitForDisplaySwitch(newState) }

                        _displaySwitchState.value = Idle(deviceStateRepository.state.value)

                    }

                } catch (e: TimeoutCancellationException) {

                    log { "tracking timed out" }

                    _displaySwitchState.value = Idle(newState, timedOut = true)

                } catch (e: CancellationException) {

                    log { "new state interrupted, entering cool down" }

                    _displaySwitchState.value = Corrupted(newState)

                    startCoolDown()

                }

            }

        }

    }



    private inline fun log(msg: () -> String) {

        if (DEBUG) Log.d(TAG, msg())

    }



    @OptIn(FlowPreview::class)

    private fun CoroutineScope.startCoolDown() {

        if (isCoolingDown) return

        isCoolingDown = true

        launch {

            val startTime = systemClock.elapsedRealtime()

            try {

                startOrEndEvent.timeout(COOL_DOWN_DURATION).collect {}

            } catch (e: TimeoutCancellationException) {

                val totalCooldownTime = systemClock.elapsedRealtime() - startTime

                instantForTrack(TAG) { "cool down finished, lasted $totalCooldownTime ms" }

                _displaySwitchState.value = Idle(deviceStateRepository.state.value)

                isCoolingDown = false

            }

        }

    }



    private suspend fun waitForDisplaySwitch(toFoldableDeviceState: DeviceState) {

        val isTransitionEnabled =

            unfoldTransitionInteractor.isAvailable &&

                animationStatusRepository.areAnimationsEnabled().first()

        if (shouldWaitForTransitionStart(toFoldableDeviceState, isTransitionEnabled)) {

            traceAsync(TAG, "waitForTransitionStart()") {

                unfoldTransitionInteractor.waitForTransitionStart()

            }

        } else {

            race({ waitForScreenTurnedOn() }, { waitForGoToSleepWithScreenOff() })

        }

    }



    private fun anyEndEventFlow(): Flow<Any> {

        val unfoldStatus =

            unfoldTransitionInteractor.unfoldTransitionStatus.filter { it is TransitionStarted }

        // dropping first emission as we're only interested in new emissions, not current state

        val screenOn =

            powerInteractor.screenPowerState.drop(1).filter { it == ScreenPowerState.SCREEN_ON }

        val goToSleep =

            powerInteractor.detailedWakefulness.drop(1).filter { sleepWithScreenOff(it) }

        return merge(screenOn, goToSleep, unfoldStatus)

    }



    private fun shouldWaitForTransitionStart(

        toFoldableDeviceState: DeviceState,

        isTransitionEnabled: Boolean,

    ): Boolean = (toFoldableDeviceState != DeviceState.FOLDED && isTransitionEnabled)



    private suspend fun waitForScreenTurnedOn() {

        traceAsync(TAG, "waitForScreenTurnedOn()") {

            // dropping first as it's stateFlow and will always emit latest value but we're

            // only interested in new states

            powerInteractor.screenPowerState

                .drop(1)

                .filter { it == ScreenPowerState.SCREEN_ON }

                .first()

        }

    }



    private suspend fun waitForGoToSleepWithScreenOff() {

        traceAsync(TAG, "waitForGoToSleepWithScreenOff()") {

            powerInteractor.detailedWakefulness.filter { sleepWithScreenOff(it) }.first()

        }

    }



    private fun sleepWithScreenOff(model: WakefulnessModel) =

        model.internalWakefulnessState == WakefulnessState.ASLEEP &&

            !keyguardInteractor.isAodAvailable.value



    companion object {

        private const val TAG = "FoldableDisplaySwitch"

        private val DEBUG = Build.IS_DEBUGGABLE



        @VisibleForTesting val COOL_DOWN_DURATION = 2.seconds

        @VisibleForTesting val SCREEN_EVENT_TIMEOUT = 15.seconds

    }

}