เพิ่มฟังก์ชันการบันทึกเวลาที่ใช้ในการโหลด

สิ่งสำคัญคือต้องบันทึกเมื่อเกมกำลังทำการโหลดสำหรับ สองเหตุผลคือ

1. เพื่อหลีกเลี่ยงไม่ให้ข้อมูลเวลาที่ใช้ในการแสดงผลเฟรมเกิดมลพิษระหว่างการโหลด
2. เพื่อวิเคราะห์เวลาในการโหลดเพื่อดูว่าเวลาและตำแหน่งที่ใช้เวลาโหลดนานกว่า ที่ยอมรับได้

เหตุการณ์การโหลดอาจมีข้อมูลเมตาที่เชื่อมโยง ได้แก่

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

ช่องใดก็ตามที่ไม่เกี่ยวข้องกับความต้องการของคุณจะมีค่าเป็น 0

เหตุการณ์การโหลดอาจมีคำอธิบายประกอบที่เชื่อมโยงด้วย คุณสามารถกำหนดใน ในลักษณะเดียวกับคำอธิบายประกอบเวลาที่ใช้ในการแสดงผลเฟรม โดยใช้ช่องอย่างน้อย 1 ช่องใน Annotation

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

ฟังก์ชันนี้จะเริ่มบันทึกเหตุการณ์เวลาที่ใช้ในการโหลดที่เชื่อมโยงกับ ข้อมูลเมตาและคำอธิบายประกอบ และใส่ค่า Result<ulong>.value เพื่อใช้ใน StopRecordingLoadingTime()

ErrorCode StopRecordingLoadingTime(ulong handle);

ฟังก์ชันนี้จะหยุดการบันทึกกิจกรรมที่เริ่มขึ้นก่อนหน้านี้โดย StartRecordingLoadingTime() ระบบจะอัปโหลดเหตุการณ์เมื่อล้างเซสชันครั้งถัดไป

กำลังโหลดฟังก์ชันกลุ่ม

คำเตือน: การโหลดทั้งหมดต้องเป็นส่วนหนึ่งของกลุ่มการโหลด โปรดดู ตัวอย่างโค้ดสำหรับการโหลดฟังก์ชันของกลุ่ม

ในเกม คุณอาจบันทึกเหตุการณ์การโหลดหลายรายการในระยะเวลาการโหลด 1 ครั้ง ที่ผู้ใช้เห็น ตัวอย่างเช่น การโหลดไฟล์ ฉาก การโหลด การคลายการบีบอัด และการคอมไพล์ตัวปรับแสงเงา

คุณควรแจ้งให้ Android Performance Tuner ทราบว่าการโหลดเป็นส่วนหนึ่ง กลุ่มดังกล่าวเพื่อให้ข้อมูลเชิงลึกที่ดีขึ้น วางแผนการโหลด เหตุการณ์ที่มีฟังก์ชันเริ่มต้นและหยุดต่อไปนี้เพื่อดำเนินการดังกล่าว

หมายเหตุ: ใช้งานกลุ่มการโหลดได้ทีละ 1 กลุ่มเท่านั้น

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

ฟังก์ชันนี้จะเริ่มกลุ่มการโหลดที่เชื่อมโยงกับข้อมูลเมตาที่ระบุ และใส่ลงใน Result<ulong>.value เพื่อใช้ใน StopLoadingGroup() ขณะนี้ข้อมูลเมตาและคำอธิบายประกอบไม่ได้ ที่ใช้โดยแบ็กเอนด์ของ Play แต่มีเฉพาะคำอธิบายประกอบเท่านั้นที่ตั้งค่าเป็น null ได้ การโหลดครั้งต่อๆ ไปทั้งหมด ถูกติดแท็กโดยรหัสกลุ่มที่ไม่ซ้ำกัน

ErrorCode StopLoadingGroup(ulong handle);

ฟังก์ชันนี้จะหยุดกลุ่มการโหลดที่เริ่มโดย StartLoadingGroup() ก่อนหน้านี้ การโหลดครั้งต่อๆ ไปจะไม่มีรหัสกลุ่มจนกว่าจะถึงวันที่ StartLoadingGroup() จะถูกเรียกอีกครั้ง

รูปที่ 1 ตัวอย่างกลุ่มการโหลด

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างบางส่วนของวิธีเพิ่มฟังก์ชันเวลาที่ใช้ในการโหลดลงในเกมของคุณ

เหตุการณ์การโหลดไฟล์

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีบันทึกเหตุการณ์การโหลดไฟล์ในเกม

public RawImage image;

IEnumerator LoadImageFromStreamingAssets(string imageName)
{
    string imagePath = "file://" + Path.Combine(Application.streamingAssetsPath, imageName);
    using (var r = UnityWebRequestTexture.GetTexture(imagePath))
    {
        LoadingTimeMetadata fileLoadingMetadata = new LoadingTimeMetadata()
        {
            state = LoadingTimeMetadata.LoadingState.InterLevel,
            source = LoadingTimeMetadata.LoadingSource.DeviceStorage,
            // Fields are zero by default but they could be set as follows
            compression_level = 0,
            network_connectivity = 0,
            network_transfer_speed_bps = 0,
            network_latency_ns = 0
        };
        Annotation annotation = new Annotation()
        {
            Scene = Scene.MagicalForest
        };
        // Start recording loading time.
        Result<ulong> result = performanceTuner.StartRecordingLoadingTime(fileLoadingMetadata, annotation);
        yield return r.SendWebRequest();
        // Stop recording loading time.
        performanceTuner.StopRecordingLoadingTime(result.value);
        if (r.isNetworkError || r.isHttpError)
        {
            Debug.Log(r.error);
        }
        else
        {
            Texture2D tex = DownloadHandlerTexture.GetContent(r);
            image.texture = tex;
        }
    }
}

เหตุการณ์การโหลดฉาก

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีบันทึกเหตุการณ์การโหลดฉากใน เกม

IEnumerator LoadScene(int sceneIndex)
{
    LoadingTimeMetadata metadata = new LoadingTimeMetadata()
        {state = LoadingTimeMetadata.LoadingState.InterLevel};
    Annotation annotation = new Annotation() {Scene = (Scene) (sceneIndex + 1)};
    Result<ulong> result = performanceTuner.StartRecordingLoadingTime(metadata, annotation);
    AsyncOperation asyncSceneLoad = SceneManager.LoadSceneAsync(sceneIndex, LoadSceneMode.Single);
    while (!asyncSceneLoad.isDone)
    {
        yield return null;
    }

    performanceTuner.StopRecordingLoadingTime(result.value);
}

กำลังโหลดฟังก์ชันกลุ่ม

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีเพิ่มฟังก์ชันของกลุ่มการโหลดไปยัง เกม

IEnumerator LoadImages()
{
    LoadingTimeMetadata groupMetadata = new LoadingTimeMetadata()
    {
        state = LoadingTimeMetadata.LoadingState.InterLevel,
        source = LoadingTimeMetadata.LoadingSource.DeviceStorage,
    };
    Result<ulong> result = performanceTuner.StartLoadingGroup(groupMetadata, null);
    yield return StartCoroutine(LoadImageFromStreamingAssets("image1.jpeg"));
    yield return StartCoroutine(LoadImageFromStreamingAssets("image2.jpeg"));
    yield return StartCoroutine(LoadImageFromStreamingAssets("image3.jpeg"));
    yield return StartCoroutine(LoadImageFromStreamingAssets("image4.jpeg"));
    var stopErrorCode = performanceTuner.StopLoadingGroup(0);
}