diff --git a/src/com/android/launcher3/Launcher.java b/src/com/android/launcher3/Launcher.java index a351947230..bc32eee717 100644 --- a/src/com/android/launcher3/Launcher.java +++ b/src/com/android/launcher3/Launcher.java @@ -49,8 +49,8 @@ import static com.android.launcher3.LauncherConstants.TraceEvents.COLD_STARTUP_T import static com.android.launcher3.LauncherConstants.TraceEvents.COLD_STARTUP_TRACE_METHOD_NAME; import static com.android.launcher3.LauncherConstants.TraceEvents.DISPLAY_ALL_APPS_TRACE_COOKIE; import static com.android.launcher3.LauncherConstants.TraceEvents.DISPLAY_ALL_APPS_TRACE_METHOD_NAME; -import static com.android.launcher3.LauncherConstants.TraceEvents.DISPLAY_WORKSPACE_TRACE_METHOD_NAME; import static com.android.launcher3.LauncherConstants.TraceEvents.DISPLAY_WORKSPACE_TRACE_COOKIE; +import static com.android.launcher3.LauncherConstants.TraceEvents.DISPLAY_WORKSPACE_TRACE_METHOD_NAME; import static com.android.launcher3.LauncherConstants.TraceEvents.ON_CREATE_EVT; import static com.android.launcher3.LauncherConstants.TraceEvents.ON_NEW_INTENT_EVT; import static com.android.launcher3.LauncherConstants.TraceEvents.ON_RESUME_EVT; @@ -86,7 +86,6 @@ import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION; import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_VIEW_INFLATION; import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC; -import static com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC; import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.COLD; import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.COLD_DEVICE_REBOOTING; import static com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType.WARM; @@ -188,6 +187,7 @@ import com.android.launcher3.keyboard.ViewGroupFocusHelper; import com.android.launcher3.logger.LauncherAtom; import com.android.launcher3.logger.LauncherAtom.ContainerInfo; import com.android.launcher3.logger.LauncherAtom.WorkspaceContainer; +import com.android.launcher3.logging.ColdRebootStartupLatencyLogger; import com.android.launcher3.logging.FileLog; import com.android.launcher3.logging.InstanceId; import com.android.launcher3.logging.InstanceIdSequence; @@ -598,13 +598,24 @@ public class Launcher extends StatefulActivity } /** - * Create {@link StartupLatencyLogger} that only collects launcher startup latency metrics - * without sending them anywhere. Child class can override this method to create logger + * We only log startup latency in {@link COLD_DEVICE_REBOOTING} type. For other latency types, + * create a no op implementation. + */ + private StartupLatencyLogger createStartupLatencyLogger( + StatsLogManager.StatsLatencyLogger.LatencyType latencyType) { + if (latencyType == COLD_DEVICE_REBOOTING) { + return createColdRebootStartupLatencyLogger(); + } + return StartupLatencyLogger.Companion.getNO_OP(); + } + + /** + * Create {@link ColdRebootStartupLatencyLogger} that only collects launcher startup latency + * metrics without sending them anywhere. Child class can override this method to create logger * that overrides {@link StartupLatencyLogger#log()} to report those metrics. */ - protected StartupLatencyLogger createStartupLatencyLogger( - StatsLogManager.StatsLatencyLogger.LatencyType latencyType) { - return new StartupLatencyLogger(latencyType); + protected ColdRebootStartupLatencyLogger createColdRebootStartupLatencyLogger() { + return new ColdRebootStartupLatencyLogger(); } /** @@ -2592,11 +2603,12 @@ public class Launcher extends StatefulActivity Trace.endAsyncSection(DISPLAY_WORKSPACE_TRACE_METHOD_NAME, DISPLAY_WORKSPACE_TRACE_COOKIE); } - mStartupLatencyLogger - .logCardinality(workspaceItemCount) - .logEnd(isBindSync - ? LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC - : LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC); + if (!isBindSync) { + mStartupLatencyLogger + .logCardinality(workspaceItemCount) + .logEnd(LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC); + } + MAIN_EXECUTOR.getHandler().postAtFrontOfQueue(() -> { mStartupLatencyLogger .logEnd(LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION) diff --git a/src/com/android/launcher3/logging/ColdRebootStartupLatencyLogger.kt b/src/com/android/launcher3/logging/ColdRebootStartupLatencyLogger.kt new file mode 100644 index 0000000000..bfc1d3a378 --- /dev/null +++ b/src/com/android/launcher3/logging/ColdRebootStartupLatencyLogger.kt @@ -0,0 +1,192 @@ +package com.android.launcher3.logging + +import android.os.SystemClock +import android.util.Log +import android.util.SparseLongArray +import androidx.annotation.MainThread +import androidx.annotation.VisibleForTesting +import androidx.core.util.contains +import androidx.core.util.isEmpty +import com.android.launcher3.BuildConfig +import com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent +import com.android.launcher3.util.Preconditions + +/** Logger for logging Launcher activity's startup latency. */ +open class ColdRebootStartupLatencyLogger : StartupLatencyLogger { + + companion object { + const val TAG = "ColdRebootStartupLatencyLogger" + const val UNSET_INT = -1 + const val UNSET_LONG = -1L + } + + @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED) + val startTimeByEvent = SparseLongArray() + @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED) + val endTimeByEvent = SparseLongArray() + + @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED) var cardinality: Int = UNSET_INT + @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED) + var workspaceLoadStartTime: Long = UNSET_LONG + + // ColdRebootStartupLatencyLogger should only send launcher startup logs once in each launcher + // activity lifecycle. After launcher activity startup is completed, the logger should be torn + // down and reject all logging calls. This flag should be checked at all APIs to prevent logging + // invalid startup metrics (such as loading workspace in screen rotation). + var isTornDown = false + private var isInTest = false + + /** Subclass can override this method to handle collected latency metrics. */ + @MainThread + override fun log(): ColdRebootStartupLatencyLogger { + return this + } + + @MainThread + override fun logWorkspaceLoadStartTime() = + logWorkspaceLoadStartTime(SystemClock.elapsedRealtime()) + + @VisibleForTesting + @MainThread + fun logWorkspaceLoadStartTime(startTimeMs: Long): ColdRebootStartupLatencyLogger { + Preconditions.assertUIThread() + if (isTornDown) { + return this + } + workspaceLoadStartTime = startTimeMs + return this + } + + /** + * Log size of workspace. Larger number of workspace items (icons, folders, widgets) means + * longer latency to initialize workspace. + */ + @MainThread + override fun logCardinality(cardinality: Int): ColdRebootStartupLatencyLogger { + Preconditions.assertUIThread() + if (isTornDown) { + return this + } + this.cardinality = cardinality + return this + } + + @MainThread + override fun logStart(event: LauncherLatencyEvent) = + logStart(event, SystemClock.elapsedRealtime()) + + @MainThread + override fun logStart( + event: LauncherLatencyEvent, + startTimeMs: Long + ): ColdRebootStartupLatencyLogger { + // In unit test no looper is attached to current thread + Preconditions.assertUIThread() + if (isTornDown) { + return this + } + if (validateLoggingEventAtStart(event)) { + startTimeByEvent.put(event.id, startTimeMs) + } + return this + } + + @MainThread + override fun logEnd(event: LauncherLatencyEvent) = logEnd(event, SystemClock.elapsedRealtime()) + + @MainThread + override fun logEnd( + event: LauncherLatencyEvent, + endTimeMs: Long + ): ColdRebootStartupLatencyLogger { + // In unit test no looper is attached to current thread + Preconditions.assertUIThread() + if (isTornDown) { + return this + } + maybeLogStartOfWorkspaceLoadTime(event) + if (validateLoggingEventAtEnd(event)) { + endTimeByEvent.put(event.id, endTimeMs) + } + + return this + } + + @MainThread + override fun reset() { + // In unit test no looper is attached to current thread + Preconditions.assertUIThread() + startTimeByEvent.clear() + endTimeByEvent.clear() + cardinality = UNSET_INT + workspaceLoadStartTime = UNSET_LONG + isTornDown = true + } + + @MainThread + private fun maybeLogStartOfWorkspaceLoadTime(event: LauncherLatencyEvent) { + if (workspaceLoadStartTime == UNSET_LONG) { + return + } + if (event == LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC) { + logStart(event, workspaceLoadStartTime) + workspaceLoadStartTime = UNSET_LONG + } + } + + /** @return true if we can log start of [LauncherLatencyEvent] and vice versa. */ + @MainThread + private fun validateLoggingEventAtStart(event: LauncherLatencyEvent): Boolean { + if (!BuildConfig.IS_STUDIO_BUILD && !isInTest) { + return true + } + if (startTimeByEvent.contains(event.id)) { + Log.e(TAG, "Cannot restart same ${event.name} event") + return false + } else if ( + startTimeByEvent.isEmpty() && + event != LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION + ) { + Log.e( + TAG, + "The first log start event must be " + + "${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION.name}.", + ) + return false + } + + return true + } + + /** @return true if we can log end of [LauncherLatencyEvent] and vice versa. */ + @MainThread + private fun validateLoggingEventAtEnd(event: LauncherLatencyEvent): Boolean { + if (!BuildConfig.IS_STUDIO_BUILD && !isInTest) { + return true + } + if (!startTimeByEvent.contains(event.id)) { + Log.e(TAG, "Cannot end ${event.name} event before starting it") + return false + } else if (endTimeByEvent.contains(event.id)) { + Log.e(TAG, "Cannot end same ${event.name} event again") + return false + } else if ( + event != LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION && + endTimeByEvent.contains( + LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION.id + ) + ) { + Log.e( + TAG, + "Cannot end ${event.name} event after ${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION.name}", + ) + return false + } + return true + } + + @VisibleForTesting + fun setIsInTest() { + isInTest = true + } +} diff --git a/src/com/android/launcher3/logging/StartupLatencyLogger.kt b/src/com/android/launcher3/logging/StartupLatencyLogger.kt index 7d7564bce9..493cd29b8f 100644 --- a/src/com/android/launcher3/logging/StartupLatencyLogger.kt +++ b/src/com/android/launcher3/logging/StartupLatencyLogger.kt @@ -1,219 +1,57 @@ +/* + * Copyright (C) 2023 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.launcher3.logging -import android.os.SystemClock -import android.util.Log -import android.util.SparseLongArray import androidx.annotation.MainThread -import androidx.annotation.VisibleForTesting -import androidx.core.util.contains -import androidx.core.util.isEmpty -import com.android.launcher3.BuildConfig -import com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent -import com.android.launcher3.logging.StatsLogManager.StatsLatencyLogger.LatencyType -import com.android.launcher3.util.Preconditions -/** Logger for logging Launcher activity's startup latency. */ -open class StartupLatencyLogger(val latencyType: LatencyType) { +/** Interface to log launcher startup latency metrics. */ +interface StartupLatencyLogger { - companion object { - const val TAG = "LauncherStartupLatencyLogger" - const val UNSET_INT = -1 - const val UNSET_LONG = -1L - } + @MainThread fun log(): StartupLatencyLogger = this - @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED) - val startTimeByEvent = SparseLongArray() - @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED) - val endTimeByEvent = SparseLongArray() - - @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED) var cardinality: Int = UNSET_INT - @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED) - var workspaceLoadStartTime: Long = UNSET_LONG - - // StartupLatencyLogger should only send launcher startup logs once in each launcher activity - // lifecycle. After launcher activity startup is completed, the logger should be torn down and - // reject all logging calls. This flag should be checked at all APIs to prevent logging invalid - // startup metrics (such as loading workspace in screen rotation). - var isTornDown = false - private var isInTest = false - - /** Subclass can override this method to handle collected latency metrics. */ - @MainThread - open fun log(): StartupLatencyLogger { - return this - } - - @MainThread - fun logWorkspaceLoadStartTime() = logWorkspaceLoadStartTime(SystemClock.elapsedRealtime()) - - @VisibleForTesting - @MainThread - fun logWorkspaceLoadStartTime(startTimeMs: Long): StartupLatencyLogger { - Preconditions.assertUIThread() - if (isTornDown) { - return this - } - workspaceLoadStartTime = startTimeMs - return this - } + @MainThread fun logWorkspaceLoadStartTime(): StartupLatencyLogger = this /** * Log size of workspace. Larger number of workspace items (icons, folders, widgets) means * longer latency to initialize workspace. */ - @MainThread - fun logCardinality(cardinality: Int): StartupLatencyLogger { - Preconditions.assertUIThread() - if (isTornDown) { - return this - } - this.cardinality = cardinality - return this - } + @MainThread fun logCardinality(cardinality: Int): StartupLatencyLogger = this @MainThread - fun logStart(event: LauncherLatencyEvent) = logStart(event, SystemClock.elapsedRealtime()) + fun logStart(event: StatsLogManager.LauncherLatencyEvent): StartupLatencyLogger = this @MainThread - fun logStart(event: LauncherLatencyEvent, startTimeMs: Long): StartupLatencyLogger { - // In unit test no looper is attached to current thread - Preconditions.assertUIThread() - if (isTornDown) { - return this - } - if (validateLoggingEventAtStart(event)) { - startTimeByEvent.put(event.id, startTimeMs) - } - return this - } + fun logStart( + event: StatsLogManager.LauncherLatencyEvent, + startTimeMs: Long + ): StartupLatencyLogger = this + + @MainThread fun logEnd(event: StatsLogManager.LauncherLatencyEvent): StartupLatencyLogger = this @MainThread - fun logEnd(event: LauncherLatencyEvent) = logEnd(event, SystemClock.elapsedRealtime()) + fun logEnd(event: StatsLogManager.LauncherLatencyEvent, endTimeMs: Long): StartupLatencyLogger = + this - @MainThread - fun logEnd(event: LauncherLatencyEvent, endTimeMs: Long): StartupLatencyLogger { - // In unit test no looper is attached to current thread - Preconditions.assertUIThread() - if (isTornDown) { - return this - } - maybeLogStartOfWorkspaceLoadTime(event) - if (validateLoggingEventAtEnd(event)) { - endTimeByEvent.put(event.id, endTimeMs) - } + @MainThread fun reset() - return this - } - - @MainThread - fun reset() { - // In unit test no looper is attached to current thread - Preconditions.assertUIThread() - startTimeByEvent.clear() - endTimeByEvent.clear() - cardinality = UNSET_INT - workspaceLoadStartTime = UNSET_LONG - isTornDown = true - } - - @MainThread - private fun maybeLogStartOfWorkspaceLoadTime(event: LauncherLatencyEvent) { - if (workspaceLoadStartTime == UNSET_LONG) { - return - } - if ( - event == LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC || - event == LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC - ) { - logStart(event, workspaceLoadStartTime) - workspaceLoadStartTime = UNSET_LONG - } - } - - /** @return true if we can log start of [LauncherLatencyEvent] and vice versa. */ - @MainThread - private fun validateLoggingEventAtStart(event: LauncherLatencyEvent): Boolean { - if (!BuildConfig.IS_STUDIO_BUILD && !isInTest) { - return true - } - if (startTimeByEvent.contains(event.id)) { - Log.e(TAG, "Cannot restart same ${event.name} event") - return false - } else if ( - startTimeByEvent.isEmpty() && - event != LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION - ) { - Log.e( - TAG, - "The first log start event must be " + - "${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION.name}.", - ) - return false - } else if ( - event == LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC && - startTimeByEvent.get( - LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC.id - ) != 0L - ) { - Log.e( - TAG, - "Cannot start ${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC.name} event after ${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC.name} starts", - ) - return false - } else if ( - event == LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC && - startTimeByEvent.get( - LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC.id - ) != 0L - ) { - Log.e( - TAG, - "Cannot start ${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC.name} event after ${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC.name} starts", - ) - return false - } - - return true - } - - /** @return true if we can log end of [LauncherLatencyEvent] and vice versa. */ - @MainThread - private fun validateLoggingEventAtEnd(event: LauncherLatencyEvent): Boolean { - if (!BuildConfig.IS_STUDIO_BUILD && !isInTest) { - return true - } - if (!startTimeByEvent.contains(event.id)) { - Log.e(TAG, "Cannot end ${event.name} event before starting it") - return false - } else if (endTimeByEvent.contains(event.id)) { - Log.e(TAG, "Cannot end same ${event.name} event again") - return false - } else if ( - event != LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION && - endTimeByEvent.contains( - LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION.id - ) - ) { - Log.e( - TAG, - "Cannot end ${event.name} event after ${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION.name}", - ) - return false - } else if ( - latencyType == LatencyType.COLD_DEVICE_REBOOTING && - event == LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC - ) { - Log.e( - TAG, - "Cannot have ${LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC.name} in ${LatencyType.COLD_DEVICE_REBOOTING.name} startup type" - ) - return false - } - return true - } - - @VisibleForTesting - fun setIsInTest() { - isInTest = true + companion object { + val NO_OP: StartupLatencyLogger = + object : StartupLatencyLogger { + override fun reset() {} + } } } diff --git a/src/com/android/launcher3/logging/StatsLogManager.java b/src/com/android/launcher3/logging/StatsLogManager.java index 632ca243e8..bad9b7908a 100644 --- a/src/com/android/launcher3/logging/StatsLogManager.java +++ b/src/com/android/launcher3/logging/StatsLogManager.java @@ -696,9 +696,6 @@ public class StatsLogManager implements ResourceBasedOverride { "The duration to inflate launcher root view in launcher activity's onCreate().") LAUNCHER_LATENCY_STARTUP_VIEW_INFLATION(1364), - @UiEvent(doc = "The duration of synchronous loading workspace") - LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC(1366), - @UiEvent(doc = "The duration of asynchronous loading workspace") LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC(1367), ; diff --git a/tests/src/com/android/launcher3/logging/StartupLatencyLoggerTest.kt b/tests/src/com/android/launcher3/logging/StartupLatencyLoggerTest.kt index a29218cc35..130dfad2ac 100644 --- a/tests/src/com/android/launcher3/logging/StartupLatencyLoggerTest.kt +++ b/tests/src/com/android/launcher3/logging/StartupLatencyLoggerTest.kt @@ -9,13 +9,12 @@ import org.junit.Before import org.junit.Test import org.junit.runner.RunWith -/** Unit test for [StartupLatencyLogger]. */ +/** Unit test for [ColdRebootStartupLatencyLogger]. */ @SmallTest @RunWith(AndroidJUnit4::class) class StartupLatencyLoggerTest { - private val underTest: StartupLatencyLogger = - StartupLatencyLogger(StatsLogManager.StatsLatencyLogger.LatencyType.COLD) + private val underTest = ColdRebootStartupLatencyLogger() @Before fun setup() { @@ -153,105 +152,6 @@ class StartupLatencyLoggerTest { .isEqualTo(111) } - @Test - @UiThreadTest - fun loadStartOfWorkspace_thenEndWithSync_logSyncStart() { - underTest - .logStart( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION, - 100 - ) - .logWorkspaceLoadStartTime(111) - - underTest.logEnd( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC, - 120 - ) - - assertThat(underTest.startTimeByEvent.size()).isEqualTo(2) - assertThat( - underTest.startTimeByEvent.get( - StatsLogManager.LauncherLatencyEvent - .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC - .id - ) - ) - .isEqualTo(111) - } - - @Test - @UiThreadTest - fun loadStartOfWorkspaceLoadSync_thenAsync_asyncNotLogged() { - underTest - .logStart( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION, - 100 - ) - .logStart( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC, - 110 - ) - - underTest.logStart( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC, - 111 - ) - - assertThat(underTest.startTimeByEvent.size()).isEqualTo(2) - assertThat( - underTest.startTimeByEvent.get( - StatsLogManager.LauncherLatencyEvent - .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC - .id - ) - ) - .isEqualTo(110) - assertThat( - underTest.startTimeByEvent.get( - StatsLogManager.LauncherLatencyEvent - .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC - .id - ) - ) - .isEqualTo(0) - } - - @Test - @UiThreadTest - fun loadStartOfWorkspaceLoadAsync_thenSync_syncNotLogged() { - underTest.logStart( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_TOTAL_DURATION, - 100 - ) - underTest.logStart( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC, - 111 - ) - - underTest.logStart( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC, - 112 - ) - - assertThat(underTest.startTimeByEvent.size()).isEqualTo(2) - assertThat( - underTest.startTimeByEvent.get( - StatsLogManager.LauncherLatencyEvent - .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC - .id - ) - ) - .isEqualTo(111) - assertThat( - underTest.startTimeByEvent.get( - StatsLogManager.LauncherLatencyEvent - .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC - .id - ) - ) - .isEqualTo(0) - } - @Test @UiThreadTest fun logEndOfEvent_withoutStartEvent_notLogged() { @@ -261,7 +161,7 @@ class StartupLatencyLoggerTest { ) underTest.logEnd( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC, + StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC, 120 ) @@ -269,7 +169,7 @@ class StartupLatencyLoggerTest { assertThat( underTest.endTimeByEvent.get( StatsLogManager.LauncherLatencyEvent - .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC + .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC .id ) ) @@ -290,7 +190,7 @@ class StartupLatencyLoggerTest { ) underTest.logEnd( - StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC, + StatsLogManager.LauncherLatencyEvent.LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC, 121 ) @@ -298,7 +198,7 @@ class StartupLatencyLoggerTest { assertThat( underTest.endTimeByEvent.get( StatsLogManager.LauncherLatencyEvent - .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_SYNC + .LAUNCHER_LATENCY_STARTUP_WORKSPACE_LOADER_ASYNC .id ) ) @@ -363,8 +263,9 @@ class StartupLatencyLoggerTest { assertThat(underTest.startTimeByEvent.isEmpty()).isTrue() assertThat(underTest.endTimeByEvent.isEmpty()).isTrue() - assertThat(underTest.cardinality).isEqualTo(StartupLatencyLogger.UNSET_INT) - assertThat(underTest.workspaceLoadStartTime).isEqualTo(StartupLatencyLogger.UNSET_LONG) + assertThat(underTest.cardinality).isEqualTo(ColdRebootStartupLatencyLogger.UNSET_INT) + assertThat(underTest.workspaceLoadStartTime) + .isEqualTo(ColdRebootStartupLatencyLogger.UNSET_LONG) assertThat(underTest.isTornDown).isTrue() } @@ -385,6 +286,6 @@ class StartupLatencyLoggerTest { .logCardinality(123) assertThat(underTest.startTimeByEvent.isEmpty()).isTrue() assertThat(underTest.endTimeByEvent.isEmpty()).isTrue() - assertThat(underTest.cardinality).isEqualTo(StartupLatencyLogger.UNSET_INT) + assertThat(underTest.cardinality).isEqualTo(ColdRebootStartupLatencyLogger.UNSET_INT) } }