### Quick Start - Java

Source: https://github.com/android/vkquality/blob/main/_autodocs/README.md

Initialize and use VKQuality in Java. Handles initialization, getting recommendations, and cleanup. Ensure to handle initialization errors.

```java
// Create instance
VKQuality vkQuality = new VKQuality(this);

// Initialize
int result = vkQuality.StartVkQualityWithFlags("", 0);
if (result != VKQuality.INIT_SUCCESS) {
    // Handle error
    return;
}

// Get recommendation
int recommendation = vkQuality.GetVkQuality();
if (recommendation >= VKQuality.RECOMMENDATION_VULKAN_BECAUSE_DEVICE_MATCH &&
    recommendation <= VKQuality.RECOMMENDATION_VULKAN_BECAUSE_FUTURE_ANDROID) {
    // Use Vulkan
} else {
    // Use OpenGL ES
}

// Cleanup
vkQuality.StopVkQuality();
```

--------------------------------

### vkqGraphicsAPIInfo Initialization Example (C)

Source: https://github.com/android/vkquality/blob/main/_autodocs/types.md

Example demonstrating how to initialize the vkqGraphicsAPIInfo structure with GLES version string and Vulkan physical device properties.

```c
VkPhysicalDeviceProperties vk_props = {...};
vkqGraphicsAPIInfo api_info = {
    .gles_version_string = "OpenGL ES 3.2",
    .vk_physical_device_properties = (void*)&vk_props
};
```

--------------------------------

### Quick Start - C/C++

Source: https://github.com/android/vkquality/blob/main/_autodocs/README.md

Initialize and use vkQuality in C/C++. Includes initialization with flags, getting recommendations, and destruction. Handles success and recommendation logic.

```c
#include "vkquality.h"

vkQualityInitResult result = vkQuality_initializeFlags(
    env, asset_mgr, cache_path, "vkqualitydata.vkq", 0);

if (result == kSuccess) {
    vkQualityRecommendation rec = vkQuality_getRecommendation();
    if (rec >= 0) {
        // Use Vulkan (recommendations 0-2)
    } else if (rec >= 3) {
        // Use OpenGL ES (recommendations 3-6)
    }
}

vkQuality_destroy(env);
```

--------------------------------

### Starting VkQuality with a Custom List

Source: https://github.com/android/vkquality/blob/main/list_editor/README.md

Demonstrates how to specify a custom .vkq file to be used by the VkQuality plugin at runtime.

```csharp
vkQuality.StartVkQuality("MyCustomFile.vkq");
```

--------------------------------

### RecordMatch Example Usage

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Demonstrates how to use the RecordMatch method with current device build properties to check for compatibility.

```java
String brand = Build.BRAND;        // "samsung"
String device = Build.DEVICE;      // "e3q"
String soc = (Build.VERSION.SDK_INT >= 31) ? Build.SOC_MODEL : "";  // "SM8650"

boolean matches = record.RecordMatch(brand, device, soc);
```

--------------------------------

### Start VkQuality with Default Data File

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Initialize VkQuality using the default data file (`vkqualitydata.vkq`). The library searches internal files and then app assets.

```java
// Use default bundled data file
int result = vkQuality.StartVkQuality(null);
// or
int result = vkQuality.StartVkQuality("");
```

--------------------------------

### Initialize vkQuality with Pre-queried Graphics Info

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Example demonstrating how to initialize the vkQuality library using the vkqGraphicsAPIInfo struct to provide pre-queried Vulkan and OpenGL ES information, bypassing library initialization.

```c
VkPhysicalDeviceProperties vk_props = ...;  // From application's Vulkan instance
const char *gles_ver = "OpenGL ES 3.2";

vkqGraphicsAPIInfo api_info = {
    .gles_version_string = gles_ver,
    .vk_physical_device_properties = (void*)&vk_props
};

vkQualityInitResult result = vkQuality_initializeFlagsInfo(
    env, assetMgr, cachePath, "vkqualitydata.vkq", &api_info, 0);
```

--------------------------------

### Start VkQuality with Initialization Flags

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Initialize VkQuality with custom data file and specific initialization flags to control behavior. Flags can be combined using bitwise OR.

```java
int result = vkQuality.StartVkQualityWithFlags("", VKQuality.INIT_FLAG_SKIP_STARTUP_MITIGATION);
```

--------------------------------

### Initialize VKQuality with Custom Data

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Starts VkQuality initialization using a specified data file. If the filename is null or empty, the default 'vkqualitydata.vkq' is used. Returns an initialization result code.

```java
int result = vkQuality.StartVkQuality("vkqualitydata.vkq");
if (result == VKQuality.INIT_SUCCESS) {
    // Initialization succeeded
}
```

--------------------------------

### Get Graphics API Recommendation

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Retrieves the recommended graphics API for the current device. This function should only be called after `vkQuality_initializeFlags()` has successfully returned `kSuccess`.

```c
vkQualityRecommendation vkQuality_getRecommendation()

```

```c
vkQualityRecommendation rec = vkQuality_getRecommendation();
switch (rec) {
    case kRecommendationVulkanBecauseDeviceMatch:
    case kRecommendationVulkanBecausePredictionMatch:
    case kRecommendationVulkanBecauseFutureAndroid:
        // Use Vulkan API
        break;
    case kRecommendationNotReady:
        // Retry after brief interval
        break;
    default:
        // Use OpenGL ES
        break;
}

```

--------------------------------

### Initialize VKQuality with Pre-computed Graphics API Info

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Example of initializing VKQuality using the vkQuality_initializeFlagsInfo function with pre-computed graphics API information. This avoids the library creating its own graphics context.

```c
VkPhysicalDeviceProperties vk_props = {...};  // From application's Vulkan instance
vkqGraphicsAPIInfo api_info = {
    .gles_version_string = nullptr,
    .vk_physical_device_properties = (void*)&vk_props
};
vkQuality_initializeFlagsInfo(env, assetMgr, cachePath, "vkqualitydata.vkq", &api_info, 0);

```

--------------------------------

### Start VkQuality with GLES Only Mitigation Flag

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Initialize VkQuality, forcing OpenGL ES recommendation for devices with known Vulkan driver issues using the `INIT_FLAG_GLES_ONLY_STARTUP_MITIGATION_DEVICES` flag.

```java
int result = vkQuality.StartVkQualityWithFlags("", 
    VKQuality.INIT_FLAG_GLES_ONLY_STARTUP_MITIGATION_DEVICES);
```

--------------------------------

### Initialize VKQuality with Flags

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Starts VkQuality initialization with custom data and specific behavior flags. Startup crash mitigation is attempted unless explicitly skipped. Returns an initialization result code.

```java
int flags = VKQuality.INIT_FLAG_SKIP_STARTUP_MITIGATION 
    | VKQuality.INIT_FLAG_SKIP_DRIVER_FINGERPRINT_CHECK;
int result = vkQuality.StartVkQualityWithFlags("custom.vkq", flags);
```

--------------------------------

### SecurityPatchDate Constructor Example

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Initializes a SecurityPatchDate object with a date string. Shows how to access parsed year, month, and day.

```java
SecurityPatchDate patchDate = new SecurityPatchDate("2024-06-01");
// patchDate.getYear() == 2024
// patchDate.getMonth() == 6
// patchDate.getDay() == 1
```

--------------------------------

### SecurityPatchDate Accessors Example

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Demonstrates retrieving the year, month, and day from a SecurityPatchDate object.

```java
SecurityPatchDate date = new SecurityPatchDate("2024-12-15");
int year = date.getYear();    // 2024
int month = date.getMonth();  // 12
int day = date.getDay();      // 15
```

--------------------------------

### Start VkQuality with Custom Data File

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Initialize VkQuality using a custom data file specified by its filename. The library prioritizes the internal files directory over app assets.

```java
// Use custom data file
int result = vkQuality.StartVkQuality("custom_quality_list.vkq");
```

--------------------------------

### Initialize vkQuality with Flags

Source: https://github.com/android/vkquality/blob/main/_autodocs/types.md

Example of initializing vkQuality using specific initialization flags. This snippet demonstrates how to set and pass the kInitFlagSkipFingerprintRecommendationCheck flag to the vkQuality_initializeFlags function.

```c
int32_t flags = kInitFlagSkipFingerprintRecommendationCheck;
vkQuality_initializeFlags(env, assetMgr, path, filename, flags);
```

--------------------------------

### Get Startup Mitigation Result String

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Retrieves a diagnostic string that describes the outcome of the startup mitigation check. This is primarily intended for logging purposes.

```java
String result = mitigation.getResultString();
Log.d("VKQUALITY", result);
// Output: "Startup mitigation: Device found in mitigation list, affected useVulkan: true"
```

--------------------------------

### VKQuality Usage Pattern

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Demonstrates a typical usage pattern for integrating the VKQuality library into an Android application, including initialization, getting recommendations, and cleanup.

```APIDOC
## Usage Pattern

```c
#include "vkquality.h"
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#include <jni.h>

void check_graphics_api(JNIEnv *env, jobject asset_mgr_obj) {
    // Initialize
    AAssetManager *asset_mgr = AAssetManager_fromJava(env, asset_mgr_obj);
    const char *cache_dir = "/data/data/com.example.app/files";
    
    vkQualityInitResult init_result = vkQuality_initializeFlags(
        env, asset_mgr, cache_dir, "vkqualitydata.vkq", 0);
    
    if (init_result != kSuccess) {
        // Handle initialization error
        return;
    }
    
    // Get recommendation
    vkQualityRecommendation rec = vkQuality_getRecommendation();
    
    if (rec == kRecommendationVulkanBecauseDeviceMatch ||
        rec == kRecommendationVulkanBecausePredictionMatch ||
        rec == kRecommendationVulkanBecauseFutureAndroid) {
        // Configure application to use Vulkan
    } else {
        // Configure application to use OpenGL ES
    }
    
    // Cleanup
    vkQuality_destroy(env);
}
```
```

--------------------------------

### Get Graphics API Recommendation

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Retrieves the recommended graphics API (Vulkan or OpenGL ES) for the current device. Handles immediate return if startup mitigation is active, otherwise queries native layers. Returns recommendation codes or error states.

```java
int recommendation = vkQuality.GetVkQuality();
switch (recommendation) {
    case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_DEVICE_MATCH:
    case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_PREDICTION_MATCH:
    case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_FUTURE_ANDROID:
        // Recommend Vulkan API
        break;
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_OLD_DEVICE:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_OLD_DRIVER:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_NO_DEVICE_MATCH:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_PREDICTION_MATCH:
        // Recommend OpenGL ES API
        break;
    case VKQuality.RECOMMENDATION_NOT_READY:
        // Retry after brief interval
        break;
}
```

--------------------------------

### Initialize VKQuality with Skip Driver Fingerprint Check Flag

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Use this Java snippet to start VKQuality while disabling SoC/driver fingerprint pair matching. This is useful when relying on device brand/model or GPU vendor/model matching, or to reduce binary data size.

```java
int result = vkQuality.StartVkQualityWithFlags("", 
    VKQuality.INIT_FLAG_SKIP_DRIVER_FINGERPRINT_CHECK);

```

--------------------------------

### VKQuality Initialization and Recommendation Handling

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

A typical usage pattern for initializing VKQuality, retrieving a graphics recommendation, and handling potential initialization errors.

```java
public class MyActivity extends Activity {
    private VKQuality vkQuality;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        vkQuality = new VKQuality(this);
        int initResult = vkQuality.StartVkQualityWithFlags("", 0);
        
        if (initResult == VKQuality.INIT_SUCCESS) {
            int recommendation = vkQuality.GetVkQuality();
            handleRecommendation(recommendation);
            vkQuality.StopVkQuality();
        } else {
            handleInitError(initResult);
        }
    }

    private void handleRecommendation(int recommendation) {
        switch (recommendation) {
            case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_DEVICE_MATCH:
            case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_PREDICTION_MATCH:
            case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_FUTURE_ANDROID:
                // Configure app to use Vulkan
                break;
            default:
                // Configure app to use OpenGL ES
                break;
        }
    }
}
```

--------------------------------

### IsEqualOrLaterThan Example Usage

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Checks if the current device's security patch date is on or after a minimum required date.

```java
SecurityPatchDate current = new SecurityPatchDate(Build.VERSION.SECURITY_PATCH);
SecurityPatchDate minimum = new SecurityPatchDate("2024-06-01");
boolean isSufficient = current.IsEqualOrLaterThan(minimum);
```

--------------------------------

### Configure for Vulkan Based on Recommendation

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Demonstrates how to apply recommendations for using Vulkan based on specific return codes from GetVkQuality(). This includes cases where the device is found in an allowlist or matches predictions.

```java
int rec = vkQuality.GetVkQuality();
if (rec == VKQuality.RECOMMENDATION_VULKAN_BECAUSE_DEVICE_MATCH ||
    rec == VKQuality.RECOMMENDATION_VULKAN_BECAUSE_PREDICTION_MATCH ||
    rec == VKQuality.RECOMMENDATION_VULKAN_BECAUSE_FUTURE_ANDROID) {
    configureForVulkan();
}
```

--------------------------------

### Minimal VKQuality Initialization (C/C++)

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

This minimal configuration is suitable for native-only applications. It requires the data file to be in the current working directory and does not support caching, leading to recomputation of recommendations each time.

```c
vkQualityInitResult result = vkQuality_initialize(
    env, nullptr, nullptr, "vkqualitydata.vkq");
```

--------------------------------

### Aggressive VKQuality Initialization

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Use this configuration when assuming devices have necessary driver patches to reduce startup time. This approach carries a higher risk of crashes on outdated devices.

```java
VKQuality vkQuality = new VKQuality(appContext);
int flags = VKQuality.INIT_FLAG_SKIP_STARTUP_MITIGATION;
int result = vkQuality.StartVkQualityWithFlags("", flags);

if (result == VKQuality.INIT_SUCCESS) {
    int recommendation = vkQuality.GetVkQuality();
    // May recommend Vulkan even on historically affected devices
    vkQuality.StopVkQuality();
}
```

--------------------------------

### Recommended Production Configuration

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Provides the standard configuration for production use, leveraging default bundled data, startup mitigation, driver fingerprint checking, and recommendation caching for optimal performance and stability.

```java
VKQuality vkQuality = new VKQuality(appContext);
int result = vkQuality.StartVkQualityWithFlags("", 0);

if (result == VKQuality.INIT_SUCCESS) {
    int recommendation = vkQuality.GetVkQuality();
    // Use recommendation
    vkQuality.StopVkQuality();
}
```

--------------------------------

### Basic vkQuality Initialization and Recommendation Query

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

A common usage pattern for the vkQuality library, showing initialization with asset manager and cache directory, querying for a graphics API recommendation, and handling the result.

```c
#include "vkquality.h"
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#include <jni.h>

void check_graphics_api(JNIEnv *env, jobject asset_mgr_obj) {
    // Initialize
    AAssetManager *asset_mgr = AAssetManager_fromJava(env, asset_mgr_obj);
    const char *cache_dir = "/data/data/com.example.app/files";
    
    vkQualityInitResult init_result = vkQuality_initializeFlags(
        env, asset_mgr, cache_dir, "vkqualitydata.vkq", 0);
    
    if (init_result != kSuccess) {
        // Handle initialization error
        return;
    }
    
    // Get recommendation
    vkQualityRecommendation rec = vkQuality_getRecommendation();
    
    if (rec == kRecommendationVulkanBecauseDeviceMatch ||
        rec == kRecommendationVulkanBecausePredictionMatch ||
        rec == kRecommendationVulkanBecauseFutureAndroid) {
        // Configure application to use Vulkan
    } else {
        // Configure application to use OpenGL ES
    }
    
    // Cleanup
    vkQuality_destroy(env);
}
```

--------------------------------

### StartVkQualityWithFlags

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Initializes VkQuality with explicit control over startup behavior via flags. Allows customization of startup crash mitigation and other behaviors. Returns an initialization result code.

```APIDOC
## StartVkQualityWithFlags

### Description
Initializes VkQuality with explicit control over startup behavior via flags. Attempts startup crash mitigation unless `INIT_FLAG_SKIP_STARTUP_MITIGATION` is set. If `customDataFilename` is null or empty, uses the default filename `vkqualitydata.vkq`.

### Method
`public int StartVkQualityWithFlags(String customDataFilename, int flags)`

### Parameters
#### Path Parameters
- **customDataFilename** (String) - Optional - Name or partial path to quality data file. If null or empty, uses default filename (`vkqualitydata.vkq`).
- **flags** (int) - Optional - Bitfield of initialization flags to alter behavior.

### Returns
`int` - One of the initialization result codes: `INIT_SUCCESS` or an `ERROR_*` constant.

### Throws/Errors
Same as `StartVkQuality()`.

### Request Example
```java
int flags = VKQuality.INIT_FLAG_SKIP_STARTUP_MITIGATION 
    | VKQuality.INIT_FLAG_SKIP_DRIVER_FINGERPRINT_CHECK;
int result = vkQuality.StartVkQualityWithFlags("custom.vkq", flags);
```
```

--------------------------------

### Handle Successful VkQuality Initialization

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Check for INIT_SUCCESS (0) after calling StartVkQualityWithFlags to ensure the library is ready for use.

```java
int result = vkQuality.StartVkQualityWithFlags("", 0);
if (result == VKQuality.INIT_SUCCESS) {
    // Proceed to GetVkQuality()
}
```

--------------------------------

### StartVkQuality

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Initializes VkQuality with optional startup crash mitigation. It uses a default quality data filename if none is provided. Returns an initialization result code.

```APIDOC
## StartVkQuality

### Description
Initializes VkQuality with optional startup crash mitigation. Equivalent to calling `StartVkQualityWithFlags(customDataFilename, 0)`. If `customDataFilename` is null or empty, uses the default filename `vkqualitydata.vkq`.

### Method
`public int StartVkQuality(String customDataFilename)`

### Parameters
#### Path Parameters
- **customDataFilename** (String) - Optional - Name or partial path to quality data file in assets or storage directory. If null or empty, uses default filename (`vkqualitydata.vkq`).

### Returns
`int` - One of the initialization result codes: `INIT_SUCCESS` or an `ERROR_*` constant.

### Throws/Errors
- `ERROR_INITIALIZATION_FAILURE` — Unspecified initialization failure
- `ERROR_NO_VULKAN` — Vulkan unavailable or failed to initialize
- `ERROR_INVALID_DATA_VERSION` — Quality data file incompatible version
- `ERROR_INVALID_DATA_FILE` — Quality data file format is invalid
- `ERROR_MISSING_DATA_FILE` — Quality data file not found in assets or storage

### Request Example
```java
int result = vkQuality.StartVkQuality("vkqualitydata.vkq");
if (result == VKQuality.INIT_SUCCESS) {
    // Initialization succeeded
}
```
```

--------------------------------

### Combining Initialization Flags

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Demonstrates how to combine multiple initialization flags using the bitwise OR operator for custom startup behavior.

```java
int flags = VKQuality.INIT_FLAG_SKIP_STARTUP_MITIGATION | VKQuality.INIT_FLAG_SKIP_DRIVER_FINGERPRINT_CHECK;
```

--------------------------------

### Unit Testing Startup Mitigation Records

Source: https://github.com/android/vkquality/blob/main/_autodocs/overview.md

Demonstrates how to create and test `StartupMitigationRecord` objects for different device profiles. Use this to verify matching logic and affected device detection.

```java
// Create records with different properties
StartupMitigationRecord samsung_affected = new StartupMitigationRecord(
    "samsung", "e3q", "", 34, 99, 
    new SecurityPatchDate("2099-12-31"),
    new SecurityPatchDate("2024-06-01"));

// Test matching
assertTrue(samsung_affected.RecordMatch("samsung", "e3q", "SM8650"));
assertTrue(samsung_affected.RecordMatch("samsung", "e3q", ""));

// Test affected device detection
int status = samsung_affected.IsDeviceAffected(34, 
    new SecurityPatchDate("2024-05-01"));
assertEquals(StartupMitigation.DEVICE_AFFECTED, status);
```

--------------------------------

### Create VKQuality Instance

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Instantiate the VKQuality class with the application context. Initialization is deferred until StartVkQuality or StartVkQualityWithFlags is called.

```java
VKQuality vkQuality = new VKQuality(this);
```

--------------------------------

### Splash Screen Initialization

Source: https://github.com/android/vkquality/blob/main/_autodocs/overview.md

Recommended pattern for initializing VkQuality on a splash screen. This avoids blocking gameplay and allows sufficient time for initialization.

```java
public class SplashActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        VKQuality vkQuality = new VKQuality(this);
        int initResult = vkQuality.StartVkQualityWithFlags("", 0);
        
        if (initResult == VKQuality.INIT_SUCCESS) {
            int recommendation = vkQuality.GetVkQuality();
            // Pass recommendation to game engine
            launchGameWithRecommendation(recommendation);
        }
        vkQuality.StopVkQuality();
    }
}
```

--------------------------------

### GetVkQuality

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Retrieves the graphics API recommendation for the current device. It returns an immediate recommendation if startup mitigation was active, otherwise it queries the native layer.

```APIDOC
## GetVkQuality

### Description
Retrieves the graphics API recommendation for the current device. If startup mitigation was active, returns the mitigation recommendation immediately. Otherwise, queries the native layer for a recommendation based on device capabilities and the quality data file.

### Method
`public int GetVkQuality()`

### Returns
`int` - One of the recommendation constants: `RECOMMENDATION_VULKAN_*`, `RECOMMENDATION_GLES_*`, `RECOMMENDATION_NOT_READY`, or `RECOMMENDATION_ERROR_NOT_INITIALIZED`.

### Request Example
```java
int recommendation = vkQuality.GetVkQuality();
switch (recommendation) {
    case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_DEVICE_MATCH:
    case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_PREDICTION_MATCH:
    case VKQuality.RECOMMENDATION_VULKAN_BECAUSE_FUTURE_ANDROID:
        // Recommend Vulkan API
        break;
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_OLD_DEVICE:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_OLD_DRIVER:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_NO_DEVICE_MATCH:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_PREDICTION_MATCH:
        // Recommend OpenGL ES API
        break;
    case VKQuality.RECOMMENDATION_NOT_READY:
        // Retry after brief interval
        break;
}
```
```

--------------------------------

### Initialize VkQuality with Default Behavior

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Initializes VkQuality using default settings, including fingerprint check. Pass JNI environment, asset manager, storage path, and the quality data filename. Returns a vkQualityInitResult indicating success or failure.

```c
vkQualityInitResult vkQuality_initialize(JNIEnv *env, 
                                         AAssetManager *asset_manager,
                                         const char *storage_path,
                                         const char *asset_filename)
```

```c
JNIEnv *env = ...;  // From current JNI context
AAssetManager *mgr = AAssetManager_fromJava(env, assetManager);
const char *cachePath = "/data/data/com.example.app/files";
vkQualityInitResult result = vkQuality_initialize(env, mgr, cachePath, "vkqualitydata.vkq");

if (result == kSuccess) {
    // Ready to call vkQuality_getRecommendation()
}
```

--------------------------------

### Handle Not Initialized Error in VKQuality

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Shows how to handle the RECOMMENDATION_ERROR_NOT_INITIALIZED error, which occurs when GetVkQuality() is called before StartVkQuality() or if initialization failed. It ensures proper initialization before retrying the call.

```java
int recommendation = vkQuality.GetVkQuality();
if (recommendation == VKQuality.RECOMMENDATION_ERROR_NOT_INITIALIZED) {
    Log.e("VKQUALITY", "GetVkQuality called before initialization");
    // Ensure StartVkQuality returned INIT_SUCCESS before calling GetVkQuality
    int initResult = vkQuality.StartVkQualityWithFlags("", 0);
    if (initResult == VKQuality.INIT_SUCCESS) {
        recommendation = vkQuality.GetVkQuality();
    }
}
```

--------------------------------

### Handle Recommendation Not Ready in VKQuality

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Illustrates how to handle the RECOMMENDATION_NOT_READY error, indicating that the recommendation is still being computed. It suggests retrying the call after a brief interval.

```java
int recommendation = vkQuality.GetVkQuality();
if (recommendation == VKQuality.RECOMMENDATION_NOT_READY) {
    // Retry after brief interval
    Thread.sleep(50);  // or use Handler.postDelayed()
    recommendation = vkQuality.GetVkQuality();
} else {
    // Recommendation is ready
    applyRecommendation(recommendation);
}
```

--------------------------------

### vkQuality_getRecommendation

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Retrieves the graphics API recommendation for the current device. Must be called after `vkQuality_initializeFlags()` returns `kSuccess`.

```APIDOC
## Function vkQuality_getRecommendation

### Description
Retrieves the graphics API recommendation for the current device. Must be called after `vkQuality_initializeFlags()` returns `kSuccess`.

### Signature
```c
vkQualityRecommendation vkQuality_getRecommendation()
```

### Returns
`vkQualityRecommendation` - One of the recommendation constants.

### Example
```c
vkQualityRecommendation rec = vkQuality_getRecommendation();
switch (rec) {
    case kRecommendationVulkanBecauseDeviceMatch:
    case kRecommendationVulkanBecausePredictionMatch:
    case kRecommendationVulkanBecauseFutureAndroid:
        // Use Vulkan API
        break;
    case kRecommendationNotReady:
        // Retry after brief interval
        break;
    default:
        // Use OpenGL ES
        break;
}
```
```

--------------------------------

### File Organization Structure

Source: https://github.com/android/vkquality/blob/main/_autodocs/README.md

Illustrates the directory structure of the VkQuality project, showing the location of README, overview, types, configuration, errors, and API reference files.

```bash
output/
├── README.md (this file)
├── overview.md (architecture, concepts, patterns)
├── types.md (all type definitions)
├── configuration.md (initialization, flags, tuning)
├── errors.md (error codes, troubleshooting)
└── api-reference/
    ├── vkquality-java.md (Java API reference)
    ├── vkquality-cpp.md (C/C++ API reference)
    └── startup-mitigation.md (Device mitigation classes)
```

--------------------------------

### VKQuality Constructor

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-java.md

Creates a new VKQuality instance. The application context is used to access assets and file directories. Initialization is deferred until StartVkQuality or StartVkQualityWithFlags is called.

```APIDOC
## VKQuality Constructor

### Description
Creates a new VKQuality instance. Does not perform any initialization until `StartVkQuality` or `StartVkQualityWithFlags` is called.

### Parameters
#### Path Parameters
- **appContext** (Context) - Required - Application context used to access assets and file directories

### Request Example
```java
VKQuality vkQuality = new VKQuality(this);
```
```

--------------------------------

### Initialize VKQuality and Handle Initialization Errors

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Initialize the VKQuality library and handle potential initialization errors such as missing data files or general initialization failures. Falls back to OpenGL ES on error.

```java
VKQuality vkQuality = new VKQuality(this);
int initResult = vkQuality.StartVkQualityWithFlags("vkqualitydata.vkq", 0);

switch (initResult) {
    case VKQuality.INIT_SUCCESS:
        int recommendation = vkQuality.GetVkQuality();
        handleRecommendation(recommendation);
        vkQuality.StopVkQuality();
        break;
    
    case VKQuality.ERROR_NO_VULKAN:
        Log.w("VKQUALITY", "Vulkan unavailable");
        // Use OpenGL ES as default
        configureForGLES();
        break;
    
    case VKQuality.ERROR_MISSING_DATA_FILE:
    case VKQuality.ERROR_INVALID_DATA_FILE:
        Log.e("VKQUALITY", "Data file problem");
        // Attempt to download/restore data file
        // or use hardcoded safe defaults
        break;
    
    case VKQuality.ERROR_INITIALIZATION_FAILURE:
    case VKQuality.ERROR_INVALID_DATA_VERSION:
    default:
        Log.e("VKQUALITY", "Unexpected initialization error: " + initResult);
        // Fallback to safe default graphics API
        configureForGLES();
        break;
}
```

--------------------------------

### Constructor for StartupMitigationRecord

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Creates a mitigation record for a specific device configuration. Matches devices by brand/device or brand/SoC pair. Use this to define criteria for when a device is considered affected by a startup issue.

```java
public StartupMitigationRecord(String Brand, 
                               String Device, 
                               String SoC,
                               int AffectedApi,
                               int FixedApi,
                               SecurityPatchDate FixedSecurityPatch,
                               SecurityPatchDate VulkanSecurityPatch)
```

```java
SecurityPatchDate fixedDate = new SecurityPatchDate("2099-12-31");
SecurityPatchDate vulkanDate = new SecurityPatchDate("2024-06-01");

StartupMitigationRecord record = new StartupMitigationRecord(
    "samsung",      // Brand
    "e3q",          // Device (Galaxy S24)
    "",             // SoC (not used when device is specified)
    34,             // Affected from API 34
    99,             // Fixed at API 99 (unreachable, only security patch matters)
    fixedDate,      // Device fixed after this date
    vulkanDate      // Vulkan safe after this date
);
```

--------------------------------

### Runtime Download and Load Custom Data File

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Shows how to download a custom VKQuality data file from a URL and load it at runtime. This allows for updating recommendations without requiring an application update.

```java
// Download from CDN/server
downloadAndSaveFile("https://example.com/vkqualitydata.vkq", 
                    getFilesDir() + "/vkqualitydata.vkq");
int result = vkQuality.StartVkQuality("vkqualitydata.vkq");
```

--------------------------------

### StartupMitigationRecord Constructor

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Creates a mitigation record for a specific device configuration. The record matches devices by brand/device pair or by brand/SoC pair depending on which is populated.

```APIDOC
## Constructor StartupMitigationRecord

### Description
Creates a mitigation record for a specific device configuration. The record matches devices by brand/device pair or by brand/SoC pair depending on which is populated.

### Parameters
#### Path Parameters
- **Brand** (String) - Yes - Device manufacturer brand (e.g., "samsung"). Empty string matches all brands.
- **Device** (String) - No - Build.DEVICE model string (e.g., "e3q"). Empty string uses SoC matching.
- **SoC** (String) - No - System-on-Chip identifier (e.g., "SM8650"). Matched as substring contains.
- **AffectedApi** (int) - Yes - Minimum Android API level affected by crash (e.g., 34)
- **FixedApi** (int) - Yes - Android API level at or above which device is unaffected (e.g., 99)
- **FixedSecurityPatch** (SecurityPatchDate) - Yes - Security patch date at or after which crash is fixed.
- **VulkanSecurityPatch** (SecurityPatchDate) - Yes - Security patch date at or after which Vulkan is safe to recommend. May be different from FixedSecurityPatch.

### Request Example
```java
SecurityPatchDate fixedDate = new SecurityPatchDate("2099-12-31");
SecurityPatchDate vulkanDate = new SecurityPatchDate("2024-06-01");

StartupMitigationRecord record = new StartupMitigationRecord(
    "samsung",      // Brand
    "e3q",          // Device (Galaxy S24)
    "",             // SoC (not used when device is specified)
    34,             // Affected from API 34
    99,             // Fixed at API 99 (unreachable, only security patch matters)
    fixedDate,      // Device fixed after this date
    vulkanDate      // Vulkan safe after this date
);
```
```

--------------------------------

### VkQuality Data Flow

Source: https://github.com/android/vkquality/blob/main/_autodocs/overview.md

Illustrates the sequence of calls and data processing from application launch to receiving a Vulkan/GLES recommendation.

```text
Application
    ↓
VKQuality.StartVkQualityWithFlags() [Java]
    ↓ (JNI)
VkQualityManager::Init() [C++]
    ↓
[StartupMitigation Check] ← Samsung Galaxy device protection
    ↓ (if not affected)
DeviceInfo Collection
    ├─ VulkanUtil::GetDeviceVulkanInfo() → VkPhysicalDeviceProperties
    ├─ GLESUtil::GetGLESStrings() → GL_VERSION, GL_VENDOR, GL_RENDERER
    └─ Build properties → brand, device, SoC, API level
    ↓
Recommendation Computation
    ├─ Device allowlist matching (brand/device/SoC)
    ├─ Driver version checks
    ├─ GPU prediction matching (allowlist/denylist)
    └─ SoC + driver fingerprint matching
    ↓
Cache Save/Load
    ↓
Application.GetVkQuality() [Java]
    ↓
Recommendation enum returned
```

--------------------------------

### vkQuality_initializeFlagsInfo

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Initializes the vkQuality library with flags and pre-queried graphics API information, allowing for advanced configuration and optimization.

```APIDOC
## vkQuality_initializeFlagsInfo

### Description
Initializes the vkQuality library with flags and pre-queried graphics API information, allowing for advanced configuration and optimization.

### Method
```c
vkQualityInitResult vkQuality_initializeFlagsInfo(JNIEnv *env, AAssetManager *asset_manager, const char *storage_path, const char *asset_filename, const vkqGraphicsAPIInfo *api_info, int32_t flags)
```

### Parameters
#### Path Parameters
- **env** (JNIEnv*) - Required - JNI environment
- **asset_manager** (AAssetManager*) - Optional - NDK Asset Manager or nullptr
- **storage_path** (const char*) - Optional - Writable directory path or nullptr
- **asset_filename** (const char*) - Required - Quality data filename
- **api_info** (vkqGraphicsAPIInfo*) - Optional - Pre-queried graphics API information. If provided, library skips API initialization.
- **flags** (int32_t) - Optional - Bitfield of initialization flags

### Use cases
- Application already has Vulkan instance and doesn't want library to create another
- Providing pre-computed graphics API info to avoid context creation overhead
- Integration with existing graphics stack

### Request Example
```c
VkPhysicalDeviceProperties vk_props = {...};  // From application's Vulkan instance
vkqGraphicsAPIInfo api_info = {
    .gles_version_string = nullptr,
    .vk_physical_device_properties = (void*)&vk_props
};
vkQuality_initializeFlagsInfo(env, assetMgr, cachePath, "vkqualitydata.vkq", &api_info, 0);
```
```

--------------------------------

### Force Cache Invalidation in Java

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Demonstrates how to manually delete the VKQuality recommendation cache file to force recomputation on the next initialization. This is useful for testing or when cache corruption is suspected.

```java
File cacheFile = new File(getFilesDir(), "vkquality_cache");
if (cacheFile.exists()) {
    cacheFile.delete();
}
// Reinitialize to recompute
int result = vkQuality.StartVkQualityWithFlags("", 0);
```

--------------------------------

### vkQuality_initialize

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Initializes the vkQuality library with essential parameters. This function is suitable for basic initialization needs.

```APIDOC
## vkQuality_initialize

### Description
Initializes the vkQuality library with essential parameters. This function is suitable for basic initialization needs.

### Method
```c
vkQualityInitResult vkQuality_initialize(JNIEnv *env, AAssetManager *asset_manager, const char *storage_path, const char *asset_filename)
```

### Parameters
#### Path Parameters
- **env** (JNIEnv*) - Required - JNI environment from current thread
- **asset_manager** (AAssetManager*) - Optional - NDK Asset Manager for accessing app bundle. Pass nullptr to disable asset lookup.
- **storage_path** (const char*) - Optional - Absolute path to writable directory for cache file (typically `app_context->getFilesDir()`). Pass nullptr to disable caching.
- **asset_filename** (const char*) - Required - Name or partial path of quality data file (e.g., "vkqualitydata.vkq")
```

--------------------------------

### Constructor for DeviceMitigationRecord

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Creates a base device matching record. This class provides the core logic for matching devices based on brand, device model, or SoC. Use this as a base for more specific mitigation records.

```java
public DeviceMitigationRecord(String Brand, String Device, String SoC)
```

```java
DeviceMitigationRecord record = new DeviceMitigationRecord("samsung", "e3q", "");
```

--------------------------------

### DeviceMitigationRecord Constructor

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Creates a base device matching record. Provides device/brand/SoC matching logic.

```APIDOC
## Constructor DeviceMitigationRecord

### Description
Creates a base device matching record. Provides device/brand/SoC matching logic.

### Parameters
#### Path Parameters
- **Brand** (String) - Yes - Device manufacturer brand. Empty string = wildcard (matches all).
- **Device** (String) - No - Build.DEVICE model string. Empty string = use SoC matching only.
- **SoC** (String) - No - System-on-Chip string. Matched via substring contains.

### Request Example
```java
DeviceMitigationRecord record = new DeviceMitigationRecord("samsung", "e3q", "");
```
```

--------------------------------

### Create StartupMitigation Instance

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Instantiates the StartupMitigation detector. This constructor automatically collects essential device information.

```java
StartupMitigation mitigation = new StartupMitigation();
```

--------------------------------

### Cached Recommendation Initialization

Source: https://github.com/android/vkquality/blob/main/_autodocs/overview.md

Utilizes a cached recommendation for instant results on repeat runs, avoiding initialization blocking. If no cache is found, it initializes VkQuality asynchronously.

```java
// Check cache
int cachedRec = getCachedRecommendation();
if (cachedRec != RECOMMENDATION_INVALID) {
    configureGraphicsAPI(cachedRec);
} else {
    // Initialize on background, save result
    initializeVkQualityAsync();
}

private void initializeVkQualityAsync() {
    VKQuality vkQuality = new VKQuality(context);
    int result = vkQuality.StartVkQualityWithFlags("", 0);
    if (result == VKQuality.INIT_SUCCESS) {
        int rec = vkQuality.GetVkQuality();
        cacheRecommendation(rec);
    }
    vkQuality.StopVkQuality();
}
```

--------------------------------

### Initialize VkQuality with Pre-queried Graphics API Info

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Use this function to initialize VkQuality when you have already queried graphics API information (e.g., Vulkan physical device properties). This avoids the library creating its own graphics contexts, which is useful for integration with existing graphics stacks. Ensure JNI environment, asset manager, storage path, and asset filename are correctly provided.

```c
vkQualityInitResult vkQuality_initializeFlagsInfo(JNIEnv *env,
                                                  AAssetManager *asset_manager,
                                                  const char *storage_path,
                                                  const char *asset_filename,
                                                  const vkqGraphicsAPIInfo *api_info,
                                                  int32_t flags)

```

```c
// Application has already queried Vulkan info via vkGetPhysicalDeviceProperties
VkPhysicalDeviceProperties vk_props = ...;

vkqGraphicsAPIInfo api_info = {
    .gles_version_string = nullptr,  // Not providing GLES info
    .vk_physical_device_properties = (void*)&vk_props
};

vkQualityInitResult result = vkQuality_initializeFlagsInfo(
    env, assetMgr, cachePath, "vkqualitydata.vkq", &api_info, 0);

```

--------------------------------

### Handle Missing Data File in VKQuality

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Demonstrates how to handle the ERROR_MISSING_DATA_FILE error by checking for the data file in assets or storage, and provides options to use a default filename or download the file from a server.

```java
int result = vkQuality.StartVkQualityWithFlags("vkqualitydata.vkq", 0);
if (result == VKQuality.ERROR_MISSING_DATA_FILE) {
    Log.e("VKQUALITY", "Data file not found");
    
    // Option 1: Use default filename
    result = vkQuality.StartVkQualityWithFlags("", 0);
    
    // Option 2: Download from CDN/server
    downloadDataFileFromServer();
    saveToFilesDir("vkqualitydata.vkq");
    result = vkQuality.StartVkQualityWithFlags("vkqualitydata.vkq", 0);
}
```

--------------------------------

### Initialize VKQuality with Context

Source: https://github.com/android/vkquality/blob/main/_autodocs/configuration.md

Instantiate VKQuality by passing the Android application context. This is required for accessing internal files and assets.

```java
VKQuality vkQuality = new VKQuality(this);  // from Activity
// or
VKQuality vkQuality = new VKQuality(context);  // from Service or other component
```

--------------------------------

### Initialize VkQuality with Custom Flags

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Initializes VkQuality with explicit control over behavior using flags. This function allows skipping the fingerprint recommendation check. It requires JNI environment, asset manager, storage path, filename, and initialization flags.

```c
vkQualityInitResult vkQuality_initializeFlags(JNIEnv *env,
                                              AAssetManager *asset_manager,
                                              const char *storage_path,
                                              const char *asset_filename,
                                              int32_t flags)
```

```c
int32_t flags = kInitFlagSkipFingerprintRecommendationCheck;
vkQualityInitResult result = vkQuality_initializeFlags(
    env, assetMgr, cachePath, "vkqualitydata.vkq", flags);
```

--------------------------------

### vkQuality_initializeFlagsInfo

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Initializes VkQuality with optional pre-collected graphics API information. This variant allows passing OpenGL ES and Vulkan properties without the library creating graphics contexts, useful for integration with existing graphics stacks.

```APIDOC
## Function vkQuality_initializeFlagsInfo

### Description
Initializes VkQuality with optional pre-collected graphics API information. This variant allows passing OpenGL ES and Vulkan properties without the library creating graphics contexts, useful for integration with existing graphics stacks.

### Signature
```c
vkQualityInitResult vkQuality_initializeFlagsInfo(JNIEnv *env,
                                                  AAssetManager *asset_manager,
                                                  const char *storage_path,
                                                  const char *asset_filename,
                                                  const vkqGraphicsAPIInfo *api_info,
                                                  int32_t flags)
```

### Parameters
#### Path Parameters
* **env** (JNIEnv*) - Yes - JNI environment pointer
* **asset_manager** (AAssetManager*) - No - Pointer to NDK Asset Manager or nullptr
* **storage_path** (const char*) - No - Writable directory path or nullptr
* **asset_filename** (const char*) - Yes - Quality data filename
* **api_info** (const vkqGraphicsAPIInfo*) - No - Optional pre-queried graphics API info. If provided, library skips initializing graphics APIs.
* **flags** (int32_t) - No - Bitfield of initialization flags

### Returns
`vkQualityInitResult` - One of: `kSuccess`, or an error code.

### Example
```c
// Application has already queried Vulkan info via vkGetPhysicalDeviceProperties
VkPhysicalDeviceProperties vk_props = ...;

vkqGraphicsAPIInfo api_info = {
    .gles_version_string = nullptr,  // Not providing GLES info
    .vk_physical_device_properties = (void*)&vk_props
};

vkQualityInitResult result = vkQuality_initializeFlagsInfo(
    env, assetMgr, cachePath, "vkqualitydata.vkq", &api_info, 0);
```

### Throws/Errors
Same as `vkQuality_initialize()`.
```

--------------------------------

### StartupMitigation Constructor

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/startup-mitigation.md

Creates a new mitigation detector. It automatically collects device information from build properties.

```APIDOC
## StartupMitigation()

### Description
Creates a new mitigation detector. Automatically collects device information from `Build.BRAND`, `Build.DEVICE`, `Build.SOC_MODEL` (SDK 31+), and `Build.VERSION.SECURITY_PATCH`.

### Example
```java
StartupMitigation mitigation = new StartupMitigation();
```
```

--------------------------------

### Handle OpenGL ES Recommendations

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Use this switch statement to configure the application for OpenGL ES based on specific recommendation codes indicating older devices or driver issues.

```java
switch (recommendation) {
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_OLD_DEVICE:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_OLD_DRIVER:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_NO_DEVICE_MATCH:
    case VKQuality.RECOMMENDATION_GLES_BECAUSE_PREDICTION_MATCH:
        configureForGLES();
        break;
}
```

--------------------------------

### vkQuality_initializeFlags

Source: https://github.com/android/vkquality/blob/main/_autodocs/api-reference/vkquality-cpp.md

Initializes VkQuality with explicit control over behavior using flags, allowing customization of the initialization process.

```APIDOC
## Function vkQuality_initializeFlags

### Description
Initializes VkQuality with explicit control via flags. Available flags: `kInitFlagSkipFingerprintRecommendationCheck`.

### Signature
```c
vkQualityInitResult vkQuality_initializeFlags(JNIEnv *env, AAssetManager *asset_manager, const char *storage_path, const char *asset_filename, int32_t flags)
```

### Parameters
#### Path Parameters
* **env** (JNIEnv*) - Yes - — - JNI environment pointer
* **asset_manager** (AAssetManager*) - No - nullptr - Pointer to NDK Asset Manager or nullptr
* **storage_path** (const char*) - No - nullptr - Writable directory path for cache or nullptr
* **asset_filename** (const char*) - Yes - — - Quality data filename
* **flags** (int32_t) - No - 0 - Bitfield of initialization flags

### Returns
`vkQualityInitResult` - One of: `kSuccess`, or an error code.

### Throws/Errors
Same as `vkQuality_initialize()`.

### Example
```c
int32_t flags = kInitFlagSkipFingerprintRecommendationCheck;
vkQualityInitResult result = vkQuality_initializeFlags(
    env, assetMgr, cachePath, "vkqualitydata.vkq", flags);
```
```

--------------------------------

### Handle No Vulkan Error in VkQuality

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Check for ERROR_NO_VULKAN (-2) if Vulkan is unavailable or failed to initialize on the device. This is a non-recoverable condition, and OpenGL ES will be used as a fallback.

```java
int result = vkQuality.StartVkQualityWithFlags("", 0);
if (result == VKQuality.ERROR_NO_VULKAN) {
    Log.e("VKQUALITY", "Vulkan not available on device");
    // Automatically use OpenGL ES as fallback
    // Vulkan is not an option on this device
}
```

--------------------------------

### Enable Java-side Logging for VKQuality

Source: https://github.com/android/vkquality/blob/main/_autodocs/errors.md

Enable detailed logging for VKQuality issues on the Java side by filtering logcat output for the 'VKQUALITY' tag.

```bash
adb logcat | grep VKQUALITY
```