Aggiungi funzioni di registrazione del tempo di caricamento

È importante registrare gli eventi di caricamento del gioco per due motivi:

1. Per evitare di inquinare i dati della durata frame durante il caricamento.
2. Per analizzare i tempi di caricamento per vedere quando e dove i tempi di caricamento sono maggiori di accettabile.

A un evento di caricamento possono essere associati metadati:

typedef struct TuningFork_LoadingTimeMetadata {
    enum LoadingState {
        UNKNOWN_STATE = 0,
        // The first time the game is run
        FIRST_RUN = 1,
        // App is not backgrounded
        COLD_START = 2,
        // App is backgrounded
        WARM_START = 3,
        // App is backgrounded, least work needed
        HOT_START = 4,
        // Asset loading between levels
        INTER_LEVEL = 5
    } state;
    enum LoadingSource {
        UNKNOWN_SOURCE = 0,
        // Uncompressing data.
        MEMORY = 1,
        // Reading assets from APK bundle.
        APK = 2,
        // Reading assets from device storage.
        DEVICE_STORAGE = 3,
        // Reading assets from external storage, e.g. SD card.
        EXTERNAL_STORAGE = 4,
        // Loading assets from the network.
        NETWORK = 5,
        // Shader compilation.
        SHADER_COMPILATION = 6,
        // Time spent between process starting and onCreate.
        PRE_ACTIVITY = 7,
        // Total time spent between process starting and first render frame.
        FIRST_TOUCH_TO_FIRST_FRAME = 8
    } source;
    int32_t compression_level;  // 0 = no compression, 100 = max compression
    enum NetworkConnectivity {
        UNKNOWN = 0,
        WIFI = 1,
        CELLULAR_NETWORK = 2
    } network_connectivity;
    uint64_t network_transfer_speed_bps;  // bandwidth in bits per second
    uint64_t network_latency_ns;          // latency in nanoseconds
} TuningFork_LoadingTimeMetadata;

I campi non pertinenti alle tue esigenze possono essere pari a zero.

Un evento di caricamento può anche essere associato a un'annotazione. Questo è definito nel nello stesso modo delle annotazioni relative alla durata frame, usando uno o più campi in Annotation nel file dev_tuningfork.proto.

TuningFork_ErrorCode TuningFork_startRecordingLoadingTime( const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation, TuningFork_LoadingEventHandle* handle);

Questa funzione avvia la registrazione di un evento relativo al tempo di caricamento associato al metadati e un'annotazione specifici e compila il campo handle da utilizzare nel Funzione TuningFork_stopRecordingLoadingTime().

TuningFork_ErrorCode TuningFork_stopRecordingLoadingTime( TuningFork_LoadingEventHandle handle);

Questa funzione interrompe la registrazione di un evento avviato precedentemente da TuningFork_startRecordingLoadingTime(). L'evento viene caricato il giorno successivo lavaggio sessione.

TuningFork_ErrorCode TuningFork_recordLoadingTime( uint64_t time_ns, const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation);

Consigliamo vivamente di utilizzare direttamente le funzioni di avvio e arresto descritti in precedenza. Se non è possibile farlo, tuttavia, è possibile richiamare questa funzione per registrare una durata e i metadati e l'annotazione associati.

Caricamento delle funzioni di gruppo in corso...

Avviso: tutti gli eventi di caricamento devono far parte di un gruppo di caricamento.

Nel tuo gioco puoi registrare diversi eventi di caricamento in un singolo periodo di caricamento. visualizzate dall'utente. Alcuni esempi includono (a titolo esemplificativo) il caricamento di file, decompression e compilation di shaker.

È importante comunicare al Tuning Fork che gli eventi di caricamento fanno parte di questo gruppo, in modo da poter fornire insight migliori. Imposta il gruppo caricare eventi con le seguenti funzioni di avvio e arresto.

Nota: può essere attivo un solo gruppo di caricamento alla volta.

TuningFork_ErrorCode TuningFork_startLoadingGroup( const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation, TuningFork_LoadingEventHandle* handle);

Questa funzione avvia un gruppo di caricamento associato al metadati e un'annotazione specifici e compila il campo handle da utilizzare nel Funzione TuningFork_stopLoadingGroup(). I metadati e l'annotazione sono attualmente non utilizzato dal backend di Google Play e può essere impostato su nullptr. Tutti i successivi eventi di caricamento verranno taggati con un ID gruppo univoco.

TuningFork_ErrorCode TuningFork_stopLoadingGroup( TuningFork_LoadingEventHandle handle);

Questa funzione interrompe un gruppo di caricamento avviato in precedenza da TuningFork_startLoadingGroup(). Gli eventi di caricamento successivi non avranno un ID gruppo fino a quando TuningFork_startLoadingGroup() non viene richiamato di nuovo.

Figura 1. Esempio del gruppo di caricamento.