Adicionar funções para gravação do tempo de carregamento

É importante registrar o jogo quando ele estiver carregando por dois motivos:

  1. Para evitar poluir os dados de tempo para a renderização do frame durante o carregamento.
  2. Para analisar os tempos de carregamento e descobrir saber quando e onde eles são mais longos do que o aceitável.

Um evento de carregamento pode ter metadados associados:

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;
}

Todos os campos que não sejam relevantes para suas necessidades podem ser definidos como zero.

Um evento de carregamento também pode ter uma anotação associada. Você pode defini-lo da mesma maneira que as anotações de tempo para a renderização do frame, usando um ou mais campos na mensagem Annotation.

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

Essa função inicia a gravação de um evento de tempo de carregamento associado aos metadados e anotações fornecidos e preenche um Result<ulong>.value para ser usado na função StopRecordingLoadingTime().

ErrorCode StopRecordingLoadingTime(ulong handle);

Essa função interrompe a gravação de um evento iniciada anteriormente por StartRecordingLoadingTime(). O upload do evento é feito na próxima limpeza de sessão.

Como carregar as funções de grupo

No seu jogo, você pode registrar vários eventos de carregamento para um único período de carregamento visto pelo usuário. Alguns exemplos incluem o carregamento de arquivos, a descompactação e a compilação do sombreador.

É importante informar ao Android Performance Tuner que os eventos de carregamento fazem parte desse grupo para que ele possa oferecer melhores insights. Coloque os eventos de carregamento entre colchetes com as seguintes funções de início e parada para fazer isso.

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

Essa função inicia um grupo de carregamento associado aos metadados e anotações fornecidos e preenche um Result<ulong>.value para ser usado na função StopLoadingGroup(). Os metadados e a anotação não são usados atualmente pelo back-end do Play e podem ser definidos como null. Todos os eventos de carregamento subsequentes terão uma tag com um ID de grupo exclusivo.

ErrorCode StopLoadingGroup(ulong handle);

Essa função interrompe um grupo de carregamento iniciado anteriormente por StartLoadingGroup(). Os eventos de carregamento subsequentes não terão um ID de grupo até que StartLoadingGroup() seja chamado novamente.