เครื่องมือแบบเนทีฟและที่เป็นกรรมสิทธิ์

เริ่มต้นใช้งาน Vulkan ใน Android

Vulkan เป็น API กราฟิกระดับล่างหลักใน Android Vulkan ให้ประสิทธิภาพที่ดีที่สุดสำหรับเกมที่ใช้เครื่องมือและโปรแกรมแสดงผลเกมของตนเอง

หากต้องการใช้ Vulkan ในเครื่องมือสร้างเกมให้สำเร็จ คุณต้องมีคุณสมบัติดังนี้

• ระบุอุปกรณ์ Android ที่จะใช้กับ Vulkan
• ทำความเข้าใจข้อดีข้อเสียของการรองรับอุปกรณ์ Android รุ่นเก่า
• เพิ่ม Vulkan ลงในเป้าหมายการสร้าง Android
• เลือกคอมไพเลอร์ Shader เพื่อสร้าง SPIR-V สำหรับ Vulkan
• กำหนดเวอร์ชัน Vulkan API ที่พร้อมใช้งานขณะรันไทม์
• ดูวิธีเพิ่มประสิทธิภาพการดำเนินการแสดงผล Vulkan ด้วยโปรไฟล์ Vulkan, การกำหนดเฟรม และการปรับภาพก่อนแสดง
• เลือกเครื่องมือกราฟิกสำหรับการแก้ไขข้อบกพร่องและการวิเคราะห์ประสิทธิภาพ

หมายเหตุ: ดูข้อมูลเกี่ยวกับการใช้ Vulkan ใน Android กับเครื่องมือเกม Unity หรือ Unreal ได้ที่
• Vulkan ใน Unity
• Vulkan ใน Unreal

เลือกข้อกำหนดขั้นต่ำของอุปกรณ์สำหรับ Vulkan

Vulkan พร้อมใช้งานใน Android ตั้งแต่เวอร์ชัน 7.0 (API ระดับ 24) ขึ้นไป อุปกรณ์ Android บางรุ่นที่ใช้ Android 7.0 ขึ้นไปอาจไม่รองรับ Vulkan คุณต้องระบุว่าเกมรองรับอุปกรณ์ Android ที่ใช้ Vulkan ได้รุ่นใดบ้าง

คำแนะนำ

ใช้ข้อกำหนดต่อไปนี้เป็นข้อกำหนดขั้นต่ำสำหรับการรองรับ Vulkan

• อุปกรณ์ใช้ Android 10.0 (API ระดับ 29) ขึ้นไป
• อุปกรณ์รองรับ Vulkan API เวอร์ชัน 1.1 ขึ้นไป
• อุปกรณ์มีความสามารถและฟีเจอร์ของฮาร์ดแวร์ที่เข้ากันได้กับโปรไฟล์พื้นฐาน Android ปี 2022

หมายเหตุ: อุปกรณ์ Android 64 บิตใหม่ตั้งแต่ Android 10.0 ขึ้นไปจำเป็นต้องรองรับ Vulkan 1.1 โปรไฟล์พื้นฐาน Android ปี 2022 ยังกำหนดเวอร์ชัน Vulkan API ขั้นต่ำเป็น 1.1 ด้วย อุปกรณ์ที่รองรับ Vulkan 1.1 ส่วนใหญ่ (แต่ไม่ใช่ทั้งหมด) ใช้งานร่วมกับโปรไฟล์พื้นฐานของ Android ปี 2022 ได้ ดูสถิติความเข้ากันได้ได้ที่แดชบอร์ดการเผยแพร่

การรองรับอุปกรณ์รุ่นเก่า

หากเกมออกแบบมาให้ทำงานได้ในอุปกรณ์ที่หลากหลายซึ่งมีความสามารถด้านกราฟิกในระดับต่างๆ คุณอาจต้องรองรับอุปกรณ์ที่เก่ากว่าอุปกรณ์ที่แนะนำในเลือกข้อกำหนดขั้นต่ำของอุปกรณ์สำหรับ Vulkan ก่อนสร้างการรองรับอุปกรณ์รุ่นเก่า ให้ประเมินว่า Vulkan มีประโยชน์ต่อเกมของคุณหรือไม่ เกมที่มีการเรียกใช้การวาดจำนวนมากและใช้ OpenGL ES อาจเห็นค่าใช้จ่ายเพิ่มเติมของไดรเวอร์อย่างมากเนื่องจากต้นทุนสูงของการทำ Draw Call ใน OpenGL ES เกมเหล่านี้อาจใช้ CPU มากเกินไปเนื่องจากใช้เวลาส่วนใหญ่ในการแสดงเฟรมในโปรแกรมควบคุมกราฟิก นอกจากนี้ เกมยังลดการใช้ CPU และพลังงานได้อย่างมากเมื่อเปลี่ยนจาก OpenGL ES เป็น Vulkan วิธีนี้เหมาะอย่างยิ่งในกรณีที่เกมมีฉากที่ซับซ้อนซึ่งใช้การสร้างอินสแตนซ์เพื่อลดการเรียกใช้การวาดภาพได้อย่างมีประสิทธิภาพ เมื่อกำหนดเป้าหมายไปยังอุปกรณ์รุ่นเก่า ให้ใส่การรองรับการแสดงผล OpenGL ES เป็นทางเลือกสำรอง เนื่องจากอุปกรณ์บางเครื่องในรายการอุปกรณ์เป้าหมายอาจใช้ Vulkan ที่ไม่ทําให้เกมทำงานได้อย่างเสถียร

คุณอาจไม่ต้องการรองรับอุปกรณ์รุ่นเก่าที่รองรับ Vulkan เนื่องจากมีประสิทธิภาพและฟีเจอร์ไม่เพียงพอ หรือมีปัญหาด้านความเสถียร

ประสิทธิภาพและฟีเจอร์

อุปกรณ์ Android เวอร์ชันเก่าที่รองรับ Vulkan อาจไม่มีประสิทธิภาพการแสดงผลหรือรองรับฮาร์ดแวร์สำหรับฟีเจอร์ที่จําเป็นต่อการทำงานของเกม ปัญหานี้อาจเกิดขึ้นได้หากเกมมีกราฟิกที่มีคุณภาพสูงและ Vulkan เป็น API เดียวที่คุณกำหนดเป้าหมายใน Android อุปกรณ์รุ่นเก่าจำนวนมากจำกัดอยู่ที่ Vulkan API เวอร์ชัน 1.0.3 และมักไม่มีส่วนขยาย Vulkan ที่ใช้กันอย่างแพร่หลายซึ่งมีอยู่ในฮาร์ดแวร์สมัยใหม่

ความเสถียร

อุปกรณ์ Android รุ่นเก่าอาจใช้ไดรเวอร์ Vulkan ที่ล้าสมัย เวอร์ชันของไดรเวอร์เหล่านี้อาจมีข้อบกพร่องที่อาจส่งผลต่อความเสถียรของเกม การแก้ปัญหาข้อบกพร่องของไดรเวอร์อาจต้องใช้เวลาในการทดสอบและวิศวกรรมเป็นจำนวนมาก

เพิ่ม Vulkan ลงในโปรเจ็กต์

หากต้องการเพิ่ม Vulkan ลงในโปรเจ็กต์ คุณต้องทำดังนี้

• รวมส่วนหัว Vulkan API
• คอมไพล์โค้ด Shader เป็น SPIR-V
• เรียกใช้ Vulkan API ที่รันไทม์

รวมส่วนหัว Vulkan API

เกมของคุณต้องมีไฟล์ส่วนหัว Vulkan API เพื่อคอมไพล์โค้ดที่ใช้ Vulkan คุณดูสำเนาส่วนหัว Vulkan ได้ใน Android NDK หรือแพ็กเกจใน Vulkan SDK เวอร์ชันต่างๆ NDK เวอร์ชันใดเวอร์ชันหนึ่งจะมีเฉพาะส่วนหัว Vulkan ที่พร้อมใช้งาน ณ เวลาที่เผยแพร่ NDK เท่านั้น หากคุณใช้ส่วนหัว Vulkan จาก NDK ให้ใช้ NDK เวอร์ชัน 25 ขึ้นไป ซึ่งมีไฟล์ส่วนหัวที่รองรับ Vulkan เวอร์ชัน 1.3 Vulkan SDK มีส่วนหัวเวอร์ชันล่าสุด

คอมไพล์โค้ด Shader เป็น SPIR-V

Vulkan API คาดหวังว่าโปรแกรม Shader จะอยู่ในรูปแบบกลางแบบไบนารี SPIR-V ข้อกำหนดนี้แตกต่างจาก OpenGL ES ซึ่งคุณสามารถส่งซอร์สโค้ดที่เขียนใน OpenGL Shading Language (GLSL) เป็นสตริงข้อความได้ ใช้คอมไพเลอร์ Shader เพื่อนำโค้ดที่เขียนด้วยภาษา Shader เช่น GLSL หรือ High-level Shader Language (HLSL) มาคอมไพล์เป็นโมดูล SPIR-V เพื่อใช้กับ Vulkan

คอมไพเลอร์ shaderc ใช้เพื่อคอมไพล์โปรแกรม shader ที่เขียนด้วย GLSL เป็น SPIR-V ได้ หากเกมใช้ HLSL DirectXShaderCompiler จะรองรับเอาต์พุต SPIR-V โดยปกติแล้ว คุณจะคอมไพล์โปรแกรม Shader ออฟไลน์เป็นส่วนหนึ่งของกระบวนการสร้างชิ้นงานสำหรับเกม และรวมโมดูล SPIR-V ไว้ในชิ้นงานรันไทม์

เรียกใช้ Vulkan API ที่รันไทม์

หากต้องการเรียกใช้ Vulkan API เกมของคุณจะต้องได้รับตัวชี้ฟังก์ชันสำหรับการเรียกใช้ Vulkan API วิธีที่ตรงที่สุดคือลิงก์กับlibvulkan.soไลบรารีที่ใช้ร่วมกันซึ่งรวมอยู่ใน Android NDK การลิงก์กับไลบรารีมีข้อบกพร่อง 2 อย่าง ได้แก่ ค่าใช้จ่ายเพิ่มเติมในการส่งผ่านฟังก์ชัน และข้อจำกัดเกี่ยวกับตัวชี้ฟังก์ชัน Vulkan API ที่ระบบจะแก้ไขโดยอัตโนมัติ

เมื่อคุณเรียกใช้ฟังก์ชัน Vulkan API ระบบจะส่งการควบคุมผ่าน dispatch table ที่จัดการโดยโครงสร้างที่เรียกว่า Vulkan Loader Android ใช้การติดตั้งใช้งานโปรแกรมโหลด Vulkan ของตัวเอง ไม่ใช่โปรแกรมโหลด LunarG ระบบโหลดนี้เป็นส่วนหนึ่งของสถาปัตยกรรมเลเยอร์ของ Vulkan API การลิงก์กับไลบรารีของระบบเมื่อสร้างจะส่งผลให้มีระดับการส่งเพิ่มเติมสำหรับการเรียก API หนึ่งๆ แม้ว่าการเรียกใช้ Vulkan จำนวนมากจะทำให้เกิดค่าใช้จ่ายเพิ่มเติมเพียงเล็กน้อย แต่ก็อาจสังเกตได้สำหรับเกมที่มีการเรียกใช้ Vulkan เป็นจำนวนมาก

โดยทั่วไปแล้ว ไลบรารีของระบบจะแก้ไขเฉพาะพอยน์เตอร์ไปยังฟังก์ชัน Vulkan ที่ถือว่าเป็นส่วนหนึ่งของ API หลัก Vulkan มีส่วนขยายจํานวนมากซึ่งกําหนดฟังก์ชัน Vulkan เพิ่มเติม ซึ่งหลายรายการไม่ได้ได้รับการแก้ไขโดยอัตโนมัติจากคลังระบบ คุณต้องแก้ไขตัวชี้ไปยังฟังก์ชัน Vulkan เหล่านี้ด้วยตนเองก่อนจึงจะใช้ได้

หากต้องการลดปัญหาเหล่านี้ ให้แก้ไขพอยน์เตอร์ไปยังฟังก์ชัน Vulkan ทั้งหมดที่คุณต้องการใช้ในรันไทม์แบบไดนามิก วิธีหนึ่งในการทำเช่นนี้คือการใช้ไลบรารีเมตาโหลดเดอร์แบบโอเพนซอร์ส เช่น volk เกมตัวอย่าง AGDKTunnel ผสานรวม volk เพื่อวัตถุประสงค์นี้ หากคุณใช้ไลบรารีตัวโหลดเมตา อย่าลิงก์กับlibvulkan.so ไลบรารีที่ใช้ร่วมกันในสคริปต์บิลด์

ระบุเวอร์ชัน Vulkan API ที่พร้อมใช้งาน

Android รองรับ Vulkan API เวอร์ชันต่อไปนี้

• 1.0.3
• 1.1
• 1.3

หมายเลขเวอร์ชัน Vulkan API สูงสุดที่ใช้ได้ในอุปกรณ์หนึ่งๆ จะกำหนดโดยเวอร์ชัน Android และการรองรับไดรเวอร์ Vulkan

เวอร์ชัน Android

การรองรับแพลตฟอร์มสำหรับเวอร์ชัน Vulkan API จะขึ้นอยู่กับเวอร์ชัน Android ขั้นต่ำ (ระดับ API) ดังนี้

• 1.3 — Android 13.0 (API ระดับ 33) ขึ้นไป
• 1.1 — Android 10.0 (API ระดับ 29) ขึ้นไป
• 1.0.3 — Android 7.0 (API ระดับ 24) ขึ้นไป

การรองรับโปรแกรมควบคุมอุปกรณ์ Vulkan

การรองรับเวอร์ชัน Vulkan API ของแพลตฟอร์ม Android ไม่ได้รับประกันว่าเวอร์ชัน API นั้นๆ ได้รับการรองรับจากไดรเวอร์ Vulkan ของอุปกรณ์ อุปกรณ์ที่ใช้ Android 13 อาจรองรับ Vulkan API เวอร์ชัน 1.1 เท่านั้น

เมื่อเริ่มต้น Vulkan อย่าขอ API เวอร์ชันที่มากกว่า

• เวอร์ชัน Vulkan API สูงสุดสำหรับเวอร์ชัน Android ที่ใช้งานในอุปกรณ์
• เวอร์ชัน Vulkan API ที่รายงานโดย vkEnumerateInstanceVersion
• เวอร์ชัน Vulkan API ที่รายงานโดยพร็อพเพอร์ตี้ apiVersion ของโครงสร้าง VkPhysicalDeviceProperties

ตัวอย่างการระบุเวอร์ชัน Vulkan API สูงสุดที่รองรับมีดังนี้

// Minimum Android API levels for Vulkan 1.3/1.1 version support
static constexpr int kMinimum_vk13_api_level = 33;
static constexpr int kMinimum_vk11_api_level = 29;

uint32_t GetHighestSupportedVulkanVersion(VkPhysicalDevice physical_device) {
  uint32_t instance_api_version = 0;
  vkEnumerateInstanceVersion(&instance_api_version);

  VkPhysicalDeviceProperties device_properties;
  vkGetPhysicalDeviceProperties(physical_device, &device_properties);

  // Instance and device versions don't have to match, use the lowest version
  // number for API support if they don't.
  const uint32_t driver_api_version =
      (instance_api_version < device_properties.apiVersion) ?
      instance_api_version : device_properties.apiVersion;

  const int device_api_level = android_get_device_api_level();
  if (device_api_level >= kMinimum_vk13_api_level &&
      driver_api_version >= VK_API_VERSION_1_3) {
    return VK_API_VERSION_1_3;
  } else if (device_api_level >= kMinimum_vk11_api_level &&
             driver_api_version >= VK_API_VERSION_1_1) {
    return VK_API_VERSION_1_1;
  }
  return VK_API_VERSION_1_0;
}

ตรวจสอบความเข้ากันได้ของโปรไฟล์ Vulkan

โปรไฟล์ Vulkan คือไฟล์ JSON ที่กำหนดชุดฟีเจอร์ ส่วนขยาย ความสามารถ และขีดจำกัดพารามิเตอร์ขั้นต่ำที่อุปกรณ์ Vulkan ต้องรองรับจึงจะใช้งานร่วมกับโปรไฟล์ได้ หากต้องการตรวจสอบว่าอุปกรณ์ใช้งานร่วมกับโปรไฟล์ Vulkan ที่เฉพาะเจาะจงได้หรือไม่ เช่น โปรไฟล์พื้นฐานของ Android ปี 2022 ให้ใช้ไลบรารี Vulkan Profiles API แบบโอเพนซอร์ส นอกจากนี้ คุณยังแยกวิเคราะห์ไฟล์ JSON ของโปรไฟล์ด้วยตนเองและค้นหาความสามารถของอุปกรณ์ได้โดยใช้ Vulkan API ที่เกี่ยวข้องเพื่อระบุความเข้ากันได้ของโปรไฟล์

โปรไฟล์ Vulkan

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

โปรไฟล์พื้นฐานของ Android (ABP) เป็นเวอร์ชันแรกในการสร้างโปรไฟล์ Vulkan ABP2021 และ ABP2022 เป็นโปรไฟล์ย้อนหลังที่มุ่งครอบคลุมอุปกรณ์ที่ใช้งานอยู่มากกว่า 85% ณ เวลานั้น จะไม่มี ABP ใหม่อีกต่อไป

โปรไฟล์ Vulkan สำหรับ Android (VPA) เป็นโปรไฟล์ใหม่ที่มีการมองการณ์ไกลโดยมีจุดมุ่งหมายเพื่อตอบสนองความต้องการของนักพัฒนาซอฟต์แวร์และขับเคลื่อนฟีเจอร์ที่สอดคล้องกันทันทีที่นักพัฒนาฮาร์ดแวร์สามารถให้บริการได้ VPA15_minimums เป็นโปรไฟล์แรกสำหรับ Android 15 และจะมี VPA ใหม่ทุกปีเพื่อครอบคลุม Android เวอร์ชันหลักแต่ละเวอร์ชัน

ใช้การกำหนดอัตราการแสดงเฟรม

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

ใช้ช่วงก่อนการหมุน

อุปกรณ์ Android สามารถแสดงในแนวตั้งและแนวนอนได้ การวางแนวของอุปกรณ์อาจแตกต่างจากการวางแนวของพื้นผิวการแสดงผล ซึ่งแตกต่างจาก OpenGL ES ใน Android ที่จัดการความคลาดเคลื่อนระหว่าง 2 รูปแบบ หากต้องการทำความเข้าใจวิธีการทำงานของกระบวนการการวางแนวและวิธีที่ดีที่สุดในการจัดการความแตกต่างของการวางแนวเมื่อใช้ Vulkan โปรดดูจัดการการหมุนอุปกรณ์ด้วย Vulkan การหมุนก่อนแสดงผล

แก้ปัญหาและโปรไฟล์การแสดงผล Vulkan

มีเครื่องมือหลายอย่างที่ช่วยในการวินิจฉัยปัญหาการแสดงผลและปัญหาด้านประสิทธิภาพของโค้ดการแสดงผล Vulkan

ดูข้อมูลเพิ่มเติมเกี่ยวกับเครื่องมือแก้ไขข้อบกพร่องและเครื่องมือวิเคราะห์ประสิทธิภาพของ Vulkan ได้ที่ส่วนเครื่องมือและฟีเจอร์ขั้นสูง

ชั้นการตรวจสอบ Vulkan

เลเยอร์การตรวจสอบ Vulkan คือไลบรารีรันไทม์ที่เปิดใช้เพื่อตรวจสอบการเรียกใช้ Vulkan API และแสดงคำเตือนหรือข้อผิดพลาดเกี่ยวกับการใช้งานที่ไม่ถูกต้องหรือไม่เหมาะสมได้ เลเยอร์การตรวจสอบเหล่านี้จะไม่ทำงานโดยค่าเริ่มต้น เนื่องจากกระบวนการตรวจสอบจะเพิ่มภาระงานรันไทม์และส่งผลต่อประสิทธิภาพของเกม ดูข้อมูลเกี่ยวกับวิธีใช้เลเยอร์การตรวจสอบกับเกมได้ที่การแก้ไขข้อบกพร่องด้วยเลเยอร์การตรวจสอบ

หมายเหตุ: ผู้ให้บริการ GPU บางรายมีไลบรารีเลเยอร์การตรวจสอบสำหรับ GPU ของตนโดยเฉพาะ นอกเหนือจากเลเยอร์การตรวจสอบ Vulkan มาตรฐาน ใช้เลเยอร์การตรวจสอบสำหรับ GPU โดยเฉพาะเพื่อรับความคิดเห็นที่ตรงจุดเกี่ยวกับ GPU บางรุ่น เลเยอร์เหล่านี้สามารถดาวน์โหลดได้จากเว็บไซต์ของนักพัฒนาแอปของผู้ให้บริการ GPU

เครื่องมือจับเฟรม

ใช้เครื่องมือจับเฟรมเพื่อบันทึกและเล่นซ้ำการเรียก Vulkan API ที่เกิดขึ้นระหว่างเฟรมเกม เครื่องมือเหล่านี้ช่วยให้คุณทำสิ่งต่อไปนี้ได้

• ดูข้อมูลและการแสดงภาพทรัพยากรกราฟิกที่มีการใช้งาน
• ดูลําดับการเรียก API ที่เกมทําและดูพารามิเตอร์ API
• สำรวจสถานะของไปป์ไลน์กราฟิก ณ เวลาที่มีการเรียกใช้การวาด
• แสดงผลลัพธ์ของการเรนเดอร์จนถึงการเรียกใช้การวาดที่เฉพาะเจาะจงในเฟรม

ใช้เครื่องมือ RenderDoc แบบโอเพนซอร์สเพื่อจับเฟรมจากเกมที่ทำงานบน Android RenderDoc รองรับการจับภาพเฟรมของทั้ง Vulkan และ OpenGL ES

นอกจากนี้ คุณยังใช้ Android GPU Inspector (AGI) เพื่อจับเฟรม Vulkan ได้ด้วย

เครื่องมือวิเคราะห์ประสิทธิภาพ

ใช้เครื่องมือวิเคราะห์ประสิทธิภาพเพื่อตรวจสอบปัญหาการแสดงผลในเกมที่ทําให้อัตราเฟรมไม่เหมาะสม ผู้ให้บริการ GPU แต่ละรายมีเครื่องมือที่ออกแบบมาเพื่อวิเคราะห์โปรไฟล์เกมและให้ข้อมูลประสิทธิภาพสำหรับสถาปัตยกรรม GPU ของตนโดยเฉพาะ ลักษณะและจุดคอขวดของประสิทธิภาพเกมอาจแตกต่างกันอย่างมากเมื่อแสดงผลบน GPU จากผู้ให้บริการรายต่างๆ หรือแม้แต่ GPU รุ่นต่างๆ จากผู้ให้บริการรายเดียวกัน

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

ปรับปรุงการทดสอบ Vulkan ด้วย CTS-D

ผู้ผลิตอุปกรณ์ที่ใช้ระบบปฏิบัติการ Android ใช้ชุดเครื่องมือทดสอบความเข้ากันได้ (CTS) เพื่อช่วยตรวจสอบว่าอุปกรณ์ของตนเข้ากันได้ CTS ที่นักพัฒนาแอปเป็นผู้ดำเนินการ (CTS-D) เป็นการทดสอบที่นักพัฒนาแอปพลิเคชัน Android ส่งเข้ามาเพื่อให้มั่นใจว่าอุปกรณ์ Android ในอนาคตจะเป็นไปตามกรณีการใช้งานและสามารถเรียกใช้แอปพลิเคชันได้อย่างราบรื่นและไม่มีข้อบกพร่อง

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

ดูขั้นตอนการส่ง CTS เพื่อดูวิธีการทีละขั้นตอนในการส่งข้อเสนอการทดสอบ