Cómo agregar funciones de grabación durante el tiempo de carga

Es importante grabar cuando el juego realiza operaciones de carga por dos motivos:

  1. Para evitar contaminar los datos de la latencia de fotogramas durante la carga
  2. Para analizar los tiempos de carga a fin de verificar cuándo y dónde son más largos de lo aceptable

Un evento de carga puede tener metadatos asociados:

public class LoadingTimeMetadata
{
    public enum LoadingState
    {
        Unknown = 0,

        /// <summary>
        ///     The first time the game is run.
        /// </summary>
        FirstRun = 1,

        /// <summary>
        ///     App is not backgrounded.
        /// </summary>
        ColdStart = 2,

        /// <summary>
        ///     App is backgrounded.
        /// </summary>
        WarmStart = 3,

        /// <summary>
        ///     App is backgrounded, least work needed.
        /// </summary>
        HotStart = 4,

        /// <summary>
        ///     Asset loading between levels.
        /// </summary>
        InterLevel = 5
    }

    public LoadingState state;

    public enum LoadingSource
    {
        UnknownSource = 0,

        /// <summary>
        ///     Uncompressing data.
        /// </summary>
        Memory = 1,

        /// <summary>
        ///     Reading assets from APK bundle.
        /// </summary>
        Apk = 2,

        /// <summary>
        ///     Reading assets from device storage.
        /// </summary>
        DeviceStorage = 3,

        /// <summary>
        ///     Reading assets from external storage, e.g. SD card.
        /// </summary>
        ExternalStorage = 4,

        /// <summary>
        ///     Loading assets from the network.
        /// </summary>
        Network = 5,

        /// <summary>
        ///     Shader compilation.
        /// </summary>
        ShaderCompilation = 6,

        /// <summary>
        ///     Time spent between process starting and onCreate.
        /// </summary>
        PreActivity = 7,

        /// <summary>
        ///     Total time spent between process starting and first render frame.
        /// </summary>
        FirstTouchToFirstFrame = 8,

        /// <summary>
        ///     Time from start to end of a group of events.
        /// </summary>
        TotalUserWaitForGroup = 9
    }

    public LoadingSource source;

    /// <summary>
    ///     0 = no compression, 100 = max compression
    /// </summary>
    public int compression_level;

    public enum NetworkConnectivity
    {
        Unknown = 0,
        Wifi = 1,
        CellularNetwork = 2
    }

    public NetworkConnectivity network_connectivity;

    /// <summary>
    ///     Bandwidth in bits per second.
    /// </summary>
    public ulong network_transfer_speed_bps;

    /// <summary>
    ///     Latency in nanoseconds.
    /// </summary>
    public ulong network_latency_ns;
}

Los campos que no sean relevantes para tus necesidades pueden ser cero.

Un evento de carga también puede tener una anotación asociada. Puedes definir de la misma manera que las anotaciones de la latencia de fotogramas, mediante uno o más campos en el mensaje Annotation.

Result<ulong> StartRecordingLoadingTime(LoadingTimeMetadata eventMetadata, TAnnotation annotation);

Esta función comienza a grabar un evento de tiempo de carga asociado con la anotación y los metadatos determinados, y completa un elemento Result<ulong>.value para usar en la función StopRecordingLoadingTime().

ErrorCode StopRecordingLoadingTime(ulong handle);

Esta función deja de grabar un evento que StartRecordingLoadingTime() inició previamente. El evento se carga en la próxima limpieza de la sesión.

Cómo cargar funciones de grupo

En tu juego, puedes grabar varios eventos de carga durante un período único de carga que ve el usuario. Algunos ejemplos son la carga de archivos, la descompresión y la compilación de sombreadores.

Es importante informar a Android Performance Tuner que los eventos de carga son parte de ese grupo para que pueda brindar mejores estadísticas. Para ello, agrupa tus eventos de carga con las siguientes funciones de inicio y finalización.

Result<ulong> StartLoadingGroup(LoadingTimeMetadata eventMetadata, TAnnotation annotation);

Esta función inicia un grupo de carga asociado con la anotación y los metadatos determinados, y completa un elemento Result<ulong>.value para usar en la función StopLoadingGroup(). Por el momento, el backend de Play no usa los metadatos ni la anotación, y se pueden establecer en null. Todos los eventos de carga posteriores se etiquetan con un ID de grupo único.

ErrorCode StopLoadingGroup(ulong handle);

Esta función detiene un grupo de carga que StartLoadingGroup() inició previamente. Los eventos de carga posteriores no tendrán un ID de grupo hasta que se vuelva a llamar a StartLoadingGroup().