2-group-android/DevCheck-lib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix

Browse Source
This commit is contained in:
lhyqy5 2025-12-09 13:48:11 +08:00
parent 6f4c66896a
commit 854a4c9e99
23 changed files with 1435 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
myphoneinfo/andinfo/src/main/AndroidManifest.xml
View File

@ -1,5 +1,10 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"> <manifest xmlns:android="http://schemas.android.com/apk/res/android">
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<application android:name=".AndInfoApp"> <application android:name=".AndInfoApp">
</application> </application>
</manifest> </manifest>

1
myphoneinfo/andinfo/src/main/cpp/CMakeLists.txt
View File

@ -13,6 +13,7 @@ add_library(andinfo SHARED
egl/EglContext.cpp egl/EglContext.cpp
egl/EglSession.cpp egl/EglSession.cpp
vulkan/VkSession.cpp vulkan/VkSession.cpp
vulkan/vkloader.cpp
vulkan_wrapper/vulkan_wrapper.cpp) vulkan_wrapper/vulkan_wrapper.cpp)
target_link_libraries(andinfo target_link_libraries(andinfo

17
myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp
View File

@ -11,13 +11,20 @@
VkSession::VkSession(const VkInstanceCreateInfo *pCreateInfo, VkSession::VkSession(const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator) { const VkAllocationCallbacks *pAllocator) {
if (!IsVulkanSupported()) { // if (!IsVulkanSupported()) {
throw std::runtime_error("Vulkan not supported"); // throw std::runtime_error("Vulkan not supported");
} // }
mLoader = new VulkanLoader();
if (vkCreateInstance(pCreateInfo, pAllocator, &mInstance) != VK_SUCCESS) { mLoader->openLib();
mLoader->loadGlobalFuncs();
if (!mLoader->createInstance(pCreateInfo, pAllocator)) {
throw std::runtime_error("Failed to create Vulkan instance"); throw std::runtime_error("Failed to create Vulkan instance");
} }
mInstance = mLoader->instance;
// if (vkCreateInstance(pCreateInfo, pAllocator, &mInstance) != VK_SUCCESS) {
// throw std::runtime_error("Failed to create Vulkan instance");
// }
} }
VkSession::~VkSession() { VkSession::~VkSession() {

71
myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp.bak Normal file
View File

@ -0,0 +1,71 @@
/*
* SPDX-FileCopyrightText: Sebastiano Barezzi
* SPDX-License-Identifier: Apache-2.0
*/
#define LOG_TAG "VkSession"
#include <stdexcept>
#include "VkSession.h"
#include "../logging.h"
VkSession::VkSession(const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator) {
// if (!IsVulkanSupported()) {
// throw std::runtime_error("Vulkan not supported");
// }
mLoader=new VulkanLoader();
if(!mLoader->createInstance(pCreateInfo,pAllocator)){
throw std::runtime_error("Failed to create Vulkan instance");
}
mInstance=mLoader->instance;
// if (vkCreateInstance(pCreateInfo, pAllocator, &mInstance) != VK_SUCCESS) {
// throw std::runtime_error("Failed to create Vulkan instance");
// }
}
VkSession::~VkSession() {
vkDestroyInstance(mInstance, nullptr);
}
std::vector<VkPhysicalDevice> VkSession::vkEnumeratePhysicalDevices() {
VkResult result;
uint32_t deviceCount = 0;
result = ::vkEnumeratePhysicalDevices(mInstance, &deviceCount, nullptr);
if (result != VK_SUCCESS) {
LOGE("Failed to enumerate Vulkan devices: %d", result);
return {};
}
if (deviceCount <= 0) {
LOGI("No Vulkan device found");
return {};
}
std::vector<VkPhysicalDevice> devices(deviceCount);
result = ::vkEnumeratePhysicalDevices(mInstance, &deviceCount, devices.data());
if (result != VK_SUCCESS) {
LOGE("Failed to enumerate Vulkan devices: %d", result);
return {};
}
return devices;
}
VkPhysicalDeviceProperties VkSession::vkGetPhysicalDeviceProperties(VkPhysicalDevice device) {
VkPhysicalDeviceProperties properties;
::vkGetPhysicalDeviceProperties(device, &properties);
return properties;
}
std::unique_ptr<VkSession> VkSession::create(const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator) {
try {
return std::unique_ptr<VkSession>(new VkSession(pCreateInfo, pAllocator));
} catch (std::runtime_error &error) {
LOGE("Failed to create Vulkan session: %s", error.what());
return nullptr;
}
}

3
myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h
View File

@ -7,7 +7,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "../vulkan_wrapper/vulkan_wrapper.h" #include "./vkloader.h"
class VkSession { class VkSession {
public: public:
@ -28,4 +28,5 @@ private:
VkSession(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator); VkSession(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator);
VkInstance mInstance = nullptr; VkInstance mInstance = nullptr;
VulkanLoader* mLoader= nullptr;
}; };

32
myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h.bak Normal file
View File

@ -0,0 +1,32 @@
/*
* SPDX-FileCopyrightText: Sebastiano Barezzi
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <memory>
#include <vector>
#include "./vkloader.h"
class VkSession {
public:
VkSession(const VkSession &) = delete;
~VkSession();
VkSession &operator=(const VkSession &) = delete;
std::vector<VkPhysicalDevice> vkEnumeratePhysicalDevices();
static std::unique_ptr<VkSession>
create(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator);
VkPhysicalDeviceProperties vkGetPhysicalDeviceProperties(VkPhysicalDevice device);
private:
VkSession(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator);
VkInstance mInstance = nullptr;
VulkanLoader* mLoader= nullptr;
};

122
myphoneinfo/andinfo/src/main/cpp/vulkan/vkloader.cpp Normal file
View File

@ -0,0 +1,122 @@
//
// Created by lhyqy5 on 2025/12/9.
//
#include "vkloader.h"
// vulkan_loader.cpp
#include <dlfcn.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define LOG(...) do { std::fprintf(stderr, __VA_ARGS__); std::fprintf(stderr, "\n"); } while(0)
VulkanLoader::VulkanLoader() {}
VulkanLoader::~VulkanLoader() {
if (instance != VK_NULL_HANDLE) {
auto vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
vkGetInstanceProcAddr(instance, "vkDestroyInstance"));
if (vkDestroyInstance) {
vkDestroyInstance(instance, nullptr);
}
instance = VK_NULL_HANDLE;
}
if (lib) {
dlclose(lib);
lib = nullptr;
}
}
bool VulkanLoader::openLib(const char* path) {
lib = dlopen(path, RTLD_NOW | RTLD_LOCAL);
if (!lib) {
LOG("dlopen(%s) failed: %s", path, dlerror());
return false;
}
void* sym = dlsym(lib, "vkGetInstanceProcAddr");
if (!sym) {
LOG("dlsym(vkGetInstanceProcAddr) returned NULL");
dlclose(lib);
lib = nullptr;
return false;
}
vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(sym);
LOG("vkGetInstanceProcAddr = %p", sym);
return true;
}
bool VulkanLoader::loadGlobalFuncs() {
if (!vkGetInstanceProcAddr) return false;
vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(
vkGetInstanceProcAddr(nullptr, "vkCreateInstance"));
vkEnumerateInstanceExtensionProperties =
reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceExtensionProperties"));
LOG("vkCreateInstance = %p", reinterpret_cast<void*>(vkCreateInstance));
LOG("vkEnumerateInstanceExtensionProperties = %p",
reinterpret_cast<void*>(vkEnumerateInstanceExtensionProperties));
return vkCreateInstance != nullptr;
}
bool VulkanLoader::createInstance(const VkInstanceCreateInfo* createInfo,
const VkAllocationCallbacks *pAllocator) {
if (!vkCreateInstance) return false;
// VkInstanceCreateInfo ci{};
// ci.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
// ci.pApplicationInfo = &appInfo;
// ci.enabledExtensionCount = (uint32_t)instanceExtensions.size();
// ci.ppEnabledExtensionNames = instanceExtensions.empty() ? nullptr : instanceExtensions.data();
VkResult r = vkCreateInstance(createInfo, pAllocator, &instance);
if (r != VK_SUCCESS) {
LOG("vkCreateInstance failed: %d", r);
return false;
}
LOG("vkCreateInstance ok, instance=%p", (void*)instance);
return true;
}
void* VulkanLoader::_getInstanceProc(const char* name) {
if (!vkGetInstanceProcAddr || instance == VK_NULL_HANDLE)
return nullptr;
void* fn = reinterpret_cast<void*>(vkGetInstanceProcAddr(instance, name));
LOG("instance-level %s = %p", name, fn);
return fn;
}
void* VulkanLoader::_getDeviceProc(VkDevice device, const char* name) {
if (!vkGetInstanceProcAddr)
return nullptr;
// get vkGetDeviceProcAddr first
auto vkGetDeviceProcAddr =
reinterpret_cast<PFN_vkGetDeviceProcAddr>(
vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr"));
if (vkGetDeviceProcAddr) {
void* fn = reinterpret_cast<void*>(vkGetDeviceProcAddr(device, name));
LOG("device-level %s = %p", name, fn);
return fn;
}
// fallback (rare) – some drivers expose device functions at instance level
void* fn = reinterpret_cast<void*>(vkGetInstanceProcAddr(instance, name));
LOG("fallback device-level %s = %p", name, fn);
return fn;
}

55
myphoneinfo/andinfo/src/main/cpp/vulkan/vkloader.h Normal file
View File

@ -0,0 +1,55 @@
//
// Created by lhyqy5 on 2025/12/9.
//
// vulkan_loader.h
#pragma once
#include <vulkan/vulkan.h>
#include <vector>
class VulkanLoader {
public:
VulkanLoader();
~VulkanLoader();
// open libvulkan.so, load vkGetInstanceProcAddr
bool openLib(const char* path = "libvulkan.so");
// load global functions such as vkCreateInstance
bool loadGlobalFuncs();
// create instance
bool createInstance(const VkInstanceCreateInfo* createInfo,
const VkAllocationCallbacks *pAllocator);
// load instance-level function
template<typename T>
T getInstanceProc(const char* name) {
return reinterpret_cast<T>(_getInstanceProc(name));
}
// load device-level function
template<typename T>
T getDeviceProc(VkDevice device, const char* name) {
return reinterpret_cast<T>(_getDeviceProc(device, name));
}
VkInstance instance = VK_NULL_HANDLE;
private:
void* lib = nullptr;
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = nullptr;
// global-level functions
PFN_vkCreateInstance vkCreateInstance = nullptr;
PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = nullptr;
// internal helpers
void* _getInstanceProc(const char* name);
void* _getDeviceProc(VkDevice device, const char* name);
// disable copy
VulkanLoader(const VulkanLoader&) = delete;
VulkanLoader& operator=(const VulkanLoader&) = delete;
};

350
myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.cpp
View File

@ -17,195 +17,207 @@ static VulkanWrapperStatus InitVulkan() {
return UNSUPPORTED; return UNSUPPORTED;
} }
auto vkGetInstanceProcAddr =
reinterpret_cast<PFN_vkGetInstanceProcAddr>(
dlsym(libvulkan, "vkGetInstanceProcAddr"));
auto vkCreateInstance =
reinterpret_cast<PFN_vkCreateInstance>(
vkGetInstanceProcAddr(nullptr, "vkCreateInstance"));
// vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(libvulkan, "vkGetInstanceProcAddr"));
// vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(dlsym(libvulkan, "vkGetDeviceProcAddr"));
auto x=vkGetInstanceProcAddr(nullptr, "vkDestroyInstance");
// Vulkan supported, set function addresses // Vulkan supported, set function addresses
vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dlsym(libvulkan, "vkCreateInstance")); // vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(vkGetInstanceProcAddr(nullptr, "vkCreateInstance"));
vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(dlsym(libvulkan, "vkDestroyInstance")); // vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(dlsym(libvulkan, "vkDestroyInstance"));
vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(dlsym(libvulkan, "vkEnumeratePhysicalDevices")); // vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(vkGetInstanceProcAddr(nullptr, "vkEnumeratePhysicalDevices"));
vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(dlsym(libvulkan, "vkGetPhysicalDeviceFeatures")); // vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceFeatures"));
vkGetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceFormatProperties")); // vkGetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceFormatProperties"));
vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceImageFormatProperties")); // vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceImageFormatProperties"));
vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceProperties")); // vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceProperties"));
vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceQueueFamilyProperties")); // vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceQueueFamilyProperties"));
vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceMemoryProperties")); // vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceMemoryProperties"));
vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(libvulkan, "vkGetInstanceProcAddr")); // vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(vkGetInstanceProcAddr(nullptr, "vkGetDeviceProcAddr"));
vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(dlsym(libvulkan, "vkGetDeviceProcAddr")); // vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(vkGetInstanceProcAddr(nullptr, "vkCreateDevice"));
vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(dlsym(libvulkan, "vkCreateDevice")); // vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(vkGetInstanceProcAddr(nullptr, "vkDestroyDevice"));
vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(dlsym(libvulkan, "vkDestroyDevice")); // vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceExtensionProperties"));
vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(dlsym(libvulkan, "vkEnumerateInstanceExtensionProperties")); // vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(vkGetInstanceProcAddr(nullptr, "vkEnumerateDeviceExtensionProperties"));
vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(dlsym(libvulkan, "vkEnumerateDeviceExtensionProperties")); // vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceLayerProperties"));
vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(dlsym(libvulkan, "vkEnumerateInstanceLayerProperties")); // vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(vkGetInstanceProcAddr(nullptr, "vkEnumerateDeviceLayerProperties"));
vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(dlsym(libvulkan, "vkEnumerateDeviceLayerProperties")); // vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(vkGetInstanceProcAddr(nullptr, "vkGetDeviceQueue"));
vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(dlsym(libvulkan, "vkGetDeviceQueue")); // vkQueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(vkGetInstanceProcAddr(nullptr, "vkQueueSubmit"));
vkQueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(dlsym(libvulkan, "vkQueueSubmit")); // vkQueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(vkGetInstanceProcAddr(nullptr, "vkQueueWaitIdle"));
vkQueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(dlsym(libvulkan, "vkQueueWaitIdle")); // vkDeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(vkGetInstanceProcAddr(nullptr, "vkDeviceWaitIdle"));
vkDeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(dlsym(libvulkan, "vkDeviceWaitIdle")); // vkAllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(vkGetInstanceProcAddr(nullptr, "vkAllocateMemory"));
vkAllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(dlsym(libvulkan, "vkAllocateMemory")); // vkFreeMemory = reinterpret_cast<PFN_vkFreeMemory>(vkGetInstanceProcAddr(nullptr, "vkFreeMemory"));
vkFreeMemory = reinterpret_cast<PFN_vkFreeMemory>(dlsym(libvulkan, "vkFreeMemory")); // vkMapMemory = reinterpret_cast<PFN_vkMapMemory>(vkGetInstanceProcAddr(nullptr, "vkMapMemory"));
vkMapMemory = reinterpret_cast<PFN_vkMapMemory>(dlsym(libvulkan, "vkMapMemory")); // vkUnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(vkGetInstanceProcAddr(nullptr, "vkUnmapMemory"));
vkUnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(dlsym(libvulkan, "vkUnmapMemory")); // vkFlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(vkGetInstanceProcAddr(nullptr, "vkFlushMappedMemoryRanges"));
vkFlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(dlsym(libvulkan, "vkFlushMappedMemoryRanges")); // vkInvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(vkGetInstanceProcAddr(nullptr, "vkInvalidateMappedMemoryRanges"));
vkInvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(dlsym(libvulkan, "vkInvalidateMappedMemoryRanges")); // vkGetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(vkGetInstanceProcAddr(nullptr, "vkGetDeviceMemoryCommitment"));
vkGetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(dlsym(libvulkan, "vkGetDeviceMemoryCommitment")); // vkBindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(vkGetInstanceProcAddr(nullptr, "vkBindBufferMemory"));
vkBindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(dlsym(libvulkan, "vkBindBufferMemory")); // vkBindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(vkGetInstanceProcAddr(nullptr, "vkBindImageMemory"));
vkBindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(dlsym(libvulkan, "vkBindImageMemory")); // vkGetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(vkGetInstanceProcAddr(nullptr, "vkGetBufferMemoryRequirements"));
vkGetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(dlsym(libvulkan, "vkGetBufferMemoryRequirements")); // vkGetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(vkGetInstanceProcAddr(nullptr, "vkGetImageMemoryRequirements"));
vkGetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(dlsym(libvulkan, "vkGetImageMemoryRequirements")); // vkGetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(vkGetInstanceProcAddr(nullptr, "vkGetImageSparseMemoryRequirements"));
vkGetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(dlsym(libvulkan, "vkGetImageSparseMemoryRequirements")); // vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceSparseImageFormatProperties"));
vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceSparseImageFormatProperties")); // vkQueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(vkGetInstanceProcAddr(nullptr, "vkQueueBindSparse"));
vkQueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(dlsym(libvulkan, "vkQueueBindSparse")); // vkCreateFence = reinterpret_cast<PFN_vkCreateFence>(vkGetInstanceProcAddr(nullptr, "vkCreateFence"));
vkCreateFence = reinterpret_cast<PFN_vkCreateFence>(dlsym(libvulkan, "vkCreateFence")); // vkDestroyFence = reinterpret_cast<PFN_vkDestroyFence>(vkGetInstanceProcAddr(nullptr, "vkDestroyFence"));
vkDestroyFence = reinterpret_cast<PFN_vkDestroyFence>(dlsym(libvulkan, "vkDestroyFence")); // vkResetFences = reinterpret_cast<PFN_vkResetFences>(vkGetInstanceProcAddr(nullptr, "vkResetFences"));
vkResetFences = reinterpret_cast<PFN_vkResetFences>(dlsym(libvulkan, "vkResetFences")); // vkGetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(vkGetInstanceProcAddr(nullptr, "vkGetFenceStatus"));
vkGetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(dlsym(libvulkan, "vkGetFenceStatus")); // vkWaitForFences = reinterpret_cast<PFN_vkWaitForFences>(vkGetInstanceProcAddr(nullptr, "vkWaitForFences"));
vkWaitForFences = reinterpret_cast<PFN_vkWaitForFences>(dlsym(libvulkan, "vkWaitForFences")); // vkCreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(vkGetInstanceProcAddr(nullptr, "vkCreateSemaphore"));
vkCreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(dlsym(libvulkan, "vkCreateSemaphore")); // vkDestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(vkGetInstanceProcAddr(nullptr, "vkDestroySemaphore"));
vkDestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(dlsym(libvulkan, "vkDestroySemaphore")); // vkCreateEvent = reinterpret_cast<PFN_vkCreateEvent>(vkGetInstanceProcAddr(nullptr, "vkCreateEvent"));
vkCreateEvent = reinterpret_cast<PFN_vkCreateEvent>(dlsym(libvulkan, "vkCreateEvent")); // vkDestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(vkGetInstanceProcAddr(nullptr, "vkDestroyEvent"));
vkDestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(dlsym(libvulkan, "vkDestroyEvent")); // vkGetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(vkGetInstanceProcAddr(nullptr, "vkGetEventStatus"));
vkGetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(dlsym(libvulkan, "vkGetEventStatus")); // vkSetEvent = reinterpret_cast<PFN_vkSetEvent>(vkGetInstanceProcAddr(nullptr, "vkSetEvent"));
vkSetEvent = reinterpret_cast<PFN_vkSetEvent>(dlsym(libvulkan, "vkSetEvent")); // vkResetEvent = reinterpret_cast<PFN_vkResetEvent>(vkGetInstanceProcAddr(nullptr, "vkResetEvent"));
vkResetEvent = reinterpret_cast<PFN_vkResetEvent>(dlsym(libvulkan, "vkResetEvent")); // vkCreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(vkGetInstanceProcAddr(nullptr, "vkCreateQueryPool"));
vkCreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(dlsym(libvulkan, "vkCreateQueryPool")); // vkDestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(vkGetInstanceProcAddr(nullptr, "vkDestroyQueryPool"));
vkDestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(dlsym(libvulkan, "vkDestroyQueryPool")); // vkGetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(vkGetInstanceProcAddr(nullptr, "vkGetQueryPoolResults"));
vkGetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(dlsym(libvulkan, "vkGetQueryPoolResults")); // vkCreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(vkGetInstanceProcAddr(nullptr, "vkCreateBuffer"));
vkCreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(dlsym(libvulkan, "vkCreateBuffer")); // vkDestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(vkGetInstanceProcAddr(nullptr, "vkDestroyBuffer"));
vkDestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(dlsym(libvulkan, "vkDestroyBuffer")); // vkCreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(vkGetInstanceProcAddr(nullptr, "vkCreateBufferView"));
vkCreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(dlsym(libvulkan, "vkCreateBufferView")); // vkDestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(vkGetInstanceProcAddr(nullptr, "vkDestroyBufferView"));
vkDestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(dlsym(libvulkan, "vkDestroyBufferView")); // vkCreateImage = reinterpret_cast<PFN_vkCreateImage>(vkGetInstanceProcAddr(nullptr, "vkCreateImage"));
vkCreateImage = reinterpret_cast<PFN_vkCreateImage>(dlsym(libvulkan, "vkCreateImage")); // vkDestroyImage = reinterpret_cast<PFN_vkDestroyImage>(vkGetInstanceProcAddr(nullptr, "vkDestroyImage"));
vkDestroyImage = reinterpret_cast<PFN_vkDestroyImage>(dlsym(libvulkan, "vkDestroyImage")); // vkGetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(vkGetInstanceProcAddr(nullptr, "vkGetImageSubresourceLayout"));
vkGetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(dlsym(libvulkan, "vkGetImageSubresourceLayout")); // vkCreateImageView = reinterpret_cast<PFN_vkCreateImageView>(vkGetInstanceProcAddr(nullptr, "vkCreateImageView"));
vkCreateImageView = reinterpret_cast<PFN_vkCreateImageView>(dlsym(libvulkan, "vkCreateImageView")); // vkDestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(vkGetInstanceProcAddr(nullptr, "vkDestroyImageView"));
vkDestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(dlsym(libvulkan, "vkDestroyImageView")); // vkCreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(vkGetInstanceProcAddr(nullptr, "vkCreateShaderModule"));
vkCreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(dlsym(libvulkan, "vkCreateShaderModule")); // vkDestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(vkGetInstanceProcAddr(nullptr, "vkDestroyShaderModule"));
vkDestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(dlsym(libvulkan, "vkDestroyShaderModule")); // vkCreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(vkGetInstanceProcAddr(nullptr, "vkCreatePipelineCache"));
vkCreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(dlsym(libvulkan, "vkCreatePipelineCache")); // vkDestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(vkGetInstanceProcAddr(nullptr, "vkDestroyPipelineCache"));
vkDestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(dlsym(libvulkan, "vkDestroyPipelineCache")); // vkGetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(vkGetInstanceProcAddr(nullptr, "vkGetPipelineCacheData"));
vkGetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(dlsym(libvulkan, "vkGetPipelineCacheData")); // vkMergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(vkGetInstanceProcAddr(nullptr, "vkMergePipelineCaches"));
vkMergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(dlsym(libvulkan, "vkMergePipelineCaches")); // vkCreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(vkGetInstanceProcAddr(nullptr, "vkCreateGraphicsPipelines"));
vkCreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(dlsym(libvulkan, "vkCreateGraphicsPipelines")); // vkCreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(vkGetInstanceProcAddr(nullptr, "vkCreateComputePipelines"));
vkCreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(dlsym(libvulkan, "vkCreateComputePipelines")); // vkDestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(vkGetInstanceProcAddr(nullptr, "vkDestroyPipeline"));
vkDestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(dlsym(libvulkan, "vkDestroyPipeline")); // vkCreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(vkGetInstanceProcAddr(nullptr, "vkCreatePipelineLayout"));
vkCreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(dlsym(libvulkan, "vkCreatePipelineLayout")); // vkDestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(vkGetInstanceProcAddr(nullptr, "vkDestroyPipelineLayout"));
vkDestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(dlsym(libvulkan, "vkDestroyPipelineLayout")); // vkCreateSampler = reinterpret_cast<PFN_vkCreateSampler>(vkGetInstanceProcAddr(nullptr, "vkCreateSampler"));
vkCreateSampler = reinterpret_cast<PFN_vkCreateSampler>(dlsym(libvulkan, "vkCreateSampler")); // vkDestroySampler = reinterpret_cast<PFN_vkDestroySampler>(vkGetInstanceProcAddr(nullptr, "vkDestroySampler"));
vkDestroySampler = reinterpret_cast<PFN_vkDestroySampler>(dlsym(libvulkan, "vkDestroySampler")); // vkCreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(vkGetInstanceProcAddr(nullptr, "vkCreateDescriptorSetLayout"));
vkCreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(dlsym(libvulkan, "vkCreateDescriptorSetLayout")); // vkDestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(vkGetInstanceProcAddr(nullptr, "vkDestroyDescriptorSetLayout"));
vkDestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(dlsym(libvulkan, "vkDestroyDescriptorSetLayout")); // vkCreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(vkGetInstanceProcAddr(nullptr, "vkCreateDescriptorPool"));
vkCreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(dlsym(libvulkan, "vkCreateDescriptorPool")); // vkDestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(vkGetInstanceProcAddr(nullptr, "vkDestroyDescriptorPool"));
vkDestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(dlsym(libvulkan, "vkDestroyDescriptorPool")); // vkResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(vkGetInstanceProcAddr(nullptr, "vkResetDescriptorPool"));
vkResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(dlsym(libvulkan, "vkResetDescriptorPool")); // vkAllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(vkGetInstanceProcAddr(nullptr, "vkAllocateDescriptorSets"));
vkAllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(dlsym(libvulkan, "vkAllocateDescriptorSets")); // vkFreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(vkGetInstanceProcAddr(nullptr, "vkFreeDescriptorSets"));
vkFreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(dlsym(libvulkan, "vkFreeDescriptorSets")); // vkUpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(vkGetInstanceProcAddr(nullptr, "vkUpdateDescriptorSets"));
vkUpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(dlsym(libvulkan, "vkUpdateDescriptorSets")); // vkCreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(vkGetInstanceProcAddr(nullptr, "vkCreateFramebuffer"));
vkCreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(dlsym(libvulkan, "vkCreateFramebuffer")); // vkDestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(vkGetInstanceProcAddr(nullptr, "vkDestroyFramebuffer"));
vkDestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(dlsym(libvulkan, "vkDestroyFramebuffer")); // vkCreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(vkGetInstanceProcAddr(nullptr, "vkCreateRenderPass"));
vkCreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(dlsym(libvulkan, "vkCreateRenderPass")); // vkDestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(vkGetInstanceProcAddr(nullptr, "vkDestroyRenderPass"));
vkDestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(dlsym(libvulkan, "vkDestroyRenderPass")); // vkGetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(vkGetInstanceProcAddr(nullptr, "vkGetRenderAreaGranularity"));
vkGetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(dlsym(libvulkan, "vkGetRenderAreaGranularity")); // vkCreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(vkGetInstanceProcAddr(nullptr, "vkCreateCommandPool"));
vkCreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(dlsym(libvulkan, "vkCreateCommandPool")); // vkDestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(vkGetInstanceProcAddr(nullptr, "vkDestroyCommandPool"));
vkDestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(dlsym(libvulkan, "vkDestroyCommandPool")); // vkResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(vkGetInstanceProcAddr(nullptr, "vkResetCommandPool"));
vkResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(dlsym(libvulkan, "vkResetCommandPool")); // vkAllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(vkGetInstanceProcAddr(nullptr, "vkAllocateCommandBuffers"));
vkAllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(dlsym(libvulkan, "vkAllocateCommandBuffers")); // vkFreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(vkGetInstanceProcAddr(nullptr, "vkFreeCommandBuffers"));
vkFreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(dlsym(libvulkan, "vkFreeCommandBuffers")); // vkBeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(vkGetInstanceProcAddr(nullptr, "vkBeginCommandBuffer"));
vkBeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(dlsym(libvulkan, "vkBeginCommandBuffer")); // vkEndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(vkGetInstanceProcAddr(nullptr, "vkEndCommandBuffer"));
vkEndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(dlsym(libvulkan, "vkEndCommandBuffer")); // vkResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(vkGetInstanceProcAddr(nullptr, "vkResetCommandBuffer"));
vkResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(dlsym(libvulkan, "vkResetCommandBuffer")); // vkCmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(vkGetInstanceProcAddr(nullptr, "vkCmdBindPipeline"));
vkCmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(dlsym(libvulkan, "vkCmdBindPipeline")); // vkCmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(vkGetInstanceProcAddr(nullptr, "vkCmdSetViewport"));
vkCmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(dlsym(libvulkan, "vkCmdSetViewport")); // vkCmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(vkGetInstanceProcAddr(nullptr, "vkCmdSetScissor"));
vkCmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(dlsym(libvulkan, "vkCmdSetScissor")); // vkCmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(vkGetInstanceProcAddr(nullptr, "vkCmdSetLineWidth"));
vkCmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(dlsym(libvulkan, "vkCmdSetLineWidth")); // vkCmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(vkGetInstanceProcAddr(nullptr, "vkCmdSetDepthBias"));
vkCmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(dlsym(libvulkan, "vkCmdSetDepthBias")); // vkCmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(vkGetInstanceProcAddr(nullptr, "vkCmdSetBlendConstants"));
vkCmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(dlsym(libvulkan, "vkCmdSetBlendConstants")); // vkCmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(vkGetInstanceProcAddr(nullptr, "vkCmdSetDepthBounds"));
vkCmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(dlsym(libvulkan, "vkCmdSetDepthBounds")); // vkCmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(vkGetInstanceProcAddr(nullptr, "vkCmdSetStencilCompareMask"));
vkCmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(dlsym(libvulkan, "vkCmdSetStencilCompareMask")); // vkCmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(vkGetInstanceProcAddr(nullptr, "vkCmdSetStencilWriteMask"));
vkCmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(dlsym(libvulkan, "vkCmdSetStencilWriteMask")); // vkCmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(vkGetInstanceProcAddr(nullptr, "vkCmdSetStencilReference"));
vkCmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(dlsym(libvulkan, "vkCmdSetStencilReference")); // vkCmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(vkGetInstanceProcAddr(nullptr, "vkCmdBindDescriptorSets"));
vkCmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(dlsym(libvulkan, "vkCmdBindDescriptorSets")); // vkCmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(vkGetInstanceProcAddr(nullptr, "vkCmdBindIndexBuffer"));
vkCmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(dlsym(libvulkan, "vkCmdBindIndexBuffer")); // vkCmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(vkGetInstanceProcAddr(nullptr, "vkCmdBindVertexBuffers"));
vkCmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(dlsym(libvulkan, "vkCmdBindVertexBuffers")); // vkCmdDraw = reinterpret_cast<PFN_vkCmdDraw>(vkGetInstanceProcAddr(nullptr, "vkCmdDraw"));
vkCmdDraw = reinterpret_cast<PFN_vkCmdDraw>(dlsym(libvulkan, "vkCmdDraw")); // vkCmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(vkGetInstanceProcAddr(nullptr, "vkCmdDrawIndexed"));
vkCmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(dlsym(libvulkan, "vkCmdDrawIndexed")); // vkCmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(vkGetInstanceProcAddr(nullptr, "vkCmdDrawIndirect"));
vkCmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(dlsym(libvulkan, "vkCmdDrawIndirect")); // vkCmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(vkGetInstanceProcAddr(nullptr, "vkCmdDrawIndexedIndirect"));
vkCmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(dlsym(libvulkan, "vkCmdDrawIndexedIndirect")); // vkCmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(vkGetInstanceProcAddr(nullptr, "vkCmdDispatch"));
vkCmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(dlsym(libvulkan, "vkCmdDispatch")); // vkCmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(vkGetInstanceProcAddr(nullptr, "vkCmdDispatchIndirect"));
vkCmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(dlsym(libvulkan, "vkCmdDispatchIndirect")); // vkCmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(vkGetInstanceProcAddr(nullptr, "vkCmdCopyBuffer"));
vkCmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(dlsym(libvulkan, "vkCmdCopyBuffer")); // vkCmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(vkGetInstanceProcAddr(nullptr, "vkCmdCopyImage"));
vkCmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(dlsym(libvulkan, "vkCmdCopyImage")); // vkCmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(vkGetInstanceProcAddr(nullptr, "vkCmdBlitImage"));
vkCmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(dlsym(libvulkan, "vkCmdBlitImage")); // vkCmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(vkGetInstanceProcAddr(nullptr, "vkCmdCopyBufferToImage"));
vkCmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(dlsym(libvulkan, "vkCmdCopyBufferToImage")); // vkCmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(vkGetInstanceProcAddr(nullptr, "vkCmdCopyImageToBuffer"));
vkCmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(dlsym(libvulkan, "vkCmdCopyImageToBuffer")); // vkCmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(vkGetInstanceProcAddr(nullptr, "vkCmdUpdateBuffer"));
vkCmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(dlsym(libvulkan, "vkCmdUpdateBuffer")); // vkCmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(vkGetInstanceProcAddr(nullptr, "vkCmdFillBuffer"));
vkCmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(dlsym(libvulkan, "vkCmdFillBuffer")); // vkCmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(vkGetInstanceProcAddr(nullptr, "vkCmdClearColorImage"));
vkCmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(dlsym(libvulkan, "vkCmdClearColorImage")); // vkCmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(vkGetInstanceProcAddr(nullptr, "vkCmdClearDepthStencilImage"));
vkCmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(dlsym(libvulkan, "vkCmdClearDepthStencilImage")); // vkCmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(vkGetInstanceProcAddr(nullptr, "vkCmdClearAttachments"));
vkCmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(dlsym(libvulkan, "vkCmdClearAttachments")); // vkCmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(vkGetInstanceProcAddr(nullptr, "vkCmdResolveImage"));
vkCmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(dlsym(libvulkan, "vkCmdResolveImage")); // vkCmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(vkGetInstanceProcAddr(nullptr, "vkCmdSetEvent"));
vkCmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(dlsym(libvulkan, "vkCmdSetEvent")); // vkCmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(vkGetInstanceProcAddr(nullptr, "vkCmdResetEvent"));
vkCmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(dlsym(libvulkan, "vkCmdResetEvent")); // vkCmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(vkGetInstanceProcAddr(nullptr, "vkCmdWaitEvents"));
vkCmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(dlsym(libvulkan, "vkCmdWaitEvents")); // vkCmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(vkGetInstanceProcAddr(nullptr, "vkCmdPipelineBarrier"));
vkCmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(dlsym(libvulkan, "vkCmdPipelineBarrier")); // vkCmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(vkGetInstanceProcAddr(nullptr, "vkCmdBeginQuery"));
vkCmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(dlsym(libvulkan, "vkCmdBeginQuery")); // vkCmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(vkGetInstanceProcAddr(nullptr, "vkCmdEndQuery"));
vkCmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(dlsym(libvulkan, "vkCmdEndQuery")); // vkCmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(vkGetInstanceProcAddr(nullptr, "vkCmdResetQueryPool"));
vkCmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(dlsym(libvulkan, "vkCmdResetQueryPool")); // vkCmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(vkGetInstanceProcAddr(nullptr, "vkCmdWriteTimestamp"));
vkCmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(dlsym(libvulkan, "vkCmdWriteTimestamp")); // vkCmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(vkGetInstanceProcAddr(nullptr, "vkCmdCopyQueryPoolResults"));
vkCmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(dlsym(libvulkan, "vkCmdCopyQueryPoolResults")); // vkCmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(vkGetInstanceProcAddr(nullptr, "vkCmdPushConstants"));
vkCmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(dlsym(libvulkan, "vkCmdPushConstants")); // vkCmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(vkGetInstanceProcAddr(nullptr, "vkCmdBeginRenderPass"));
vkCmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(dlsym(libvulkan, "vkCmdBeginRenderPass")); // vkCmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(vkGetInstanceProcAddr(nullptr, "vkCmdNextSubpass"));
vkCmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(dlsym(libvulkan, "vkCmdNextSubpass")); // vkCmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(vkGetInstanceProcAddr(nullptr, "vkCmdEndRenderPass"));
vkCmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(dlsym(libvulkan, "vkCmdEndRenderPass")); // vkCmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(vkGetInstanceProcAddr(nullptr, "vkCmdExecuteCommands"));
vkCmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(dlsym(libvulkan, "vkCmdExecuteCommands")); // vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(vkGetInstanceProcAddr(nullptr, "vkDestroySurfaceKHR"));
vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(dlsym(libvulkan, "vkDestroySurfaceKHR")); // vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceSurfaceSupportKHR"));
vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceSupportKHR")); // vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); // vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceFormatsKHR")); // vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfacePresentModesKHR")); // vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateSwapchainKHR"));
vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(dlsym(libvulkan, "vkCreateSwapchainKHR")); // vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(vkGetInstanceProcAddr(nullptr, "vkDestroySwapchainKHR"));
vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(dlsym(libvulkan, "vkDestroySwapchainKHR")); // vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(vkGetInstanceProcAddr(nullptr, "vkGetSwapchainImagesKHR"));
vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(dlsym(libvulkan, "vkGetSwapchainImagesKHR")); // vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(vkGetInstanceProcAddr(nullptr, "vkAcquireNextImageKHR"));
vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(dlsym(libvulkan, "vkAcquireNextImageKHR")); // vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(vkGetInstanceProcAddr(nullptr, "vkQueuePresentKHR"));
vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(dlsym(libvulkan, "vkQueuePresentKHR")); // vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPropertiesKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceDisplayPropertiesKHR"));
// vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPropertiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceDisplayPropertiesKHR")); // vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
// vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); // vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast<PFN_vkGetDisplayPlaneSupportedDisplaysKHR>(vkGetInstanceProcAddr(nullptr, "vkGetDisplayPlaneSupportedDisplaysKHR"));
// vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast<PFN_vkGetDisplayPlaneSupportedDisplaysKHR>(dlsym(libvulkan, "vkGetDisplayPlaneSupportedDisplaysKHR")); // vkGetDisplayModePropertiesKHR = reinterpret_cast<PFN_vkGetDisplayModePropertiesKHR>(vkGetInstanceProcAddr(nullptr, "vkGetDisplayModePropertiesKHR"));
// vkGetDisplayModePropertiesKHR = reinterpret_cast<PFN_vkGetDisplayModePropertiesKHR>(dlsym(libvulkan, "vkGetDisplayModePropertiesKHR")); // vkCreateDisplayModeKHR = reinterpret_cast<PFN_vkCreateDisplayModeKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateDisplayModeKHR"));
// vkCreateDisplayModeKHR = reinterpret_cast<PFN_vkCreateDisplayModeKHR>(dlsym(libvulkan, "vkCreateDisplayModeKHR")); // vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast<PFN_vkGetDisplayPlaneCapabilitiesKHR>(vkGetInstanceProcAddr(nullptr, "vkGetDisplayPlaneCapabilitiesKHR"));
// vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast<PFN_vkGetDisplayPlaneCapabilitiesKHR>(dlsym(libvulkan, "vkGetDisplayPlaneCapabilitiesKHR")); // vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast<PFN_vkCreateDisplayPlaneSurfaceKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateDisplayPlaneSurfaceKHR"));
// vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast<PFN_vkCreateDisplayPlaneSurfaceKHR>(dlsym(libvulkan, "vkCreateDisplayPlaneSurfaceKHR")); // vkCreateSharedSwapchainsKHR = reinterpret_cast<PFN_vkCreateSharedSwapchainsKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateSharedSwapchainsKHR"));
// vkCreateSharedSwapchainsKHR = reinterpret_cast<PFN_vkCreateSharedSwapchainsKHR>(dlsym(libvulkan, "vkCreateSharedSwapchainsKHR"));
#ifdef VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR
// vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(dlsym(libvulkan, "vkCreateXlibSurfaceKHR")); // vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateXlibSurfaceKHR"));
// vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceXlibPresentationSupportKHR")); // vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
#endif #endif
#ifdef VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XCB_KHR
// vkCreateXcbSurfaceKHR = reinterpret_cast<PFN_vkCreateXcbSurfaceKHR>(dlsym(libvulkan, "vkCreateXcbSurfaceKHR")); // vkCreateXcbSurfaceKHR = reinterpret_cast<PFN_vkCreateXcbSurfaceKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateXcbSurfaceKHR"));
// vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceXcbPresentationSupportKHR")); // vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
#endif #endif
#ifdef VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR
// vkCreateWaylandSurfaceKHR = reinterpret_cast<PFN_vkCreateWaylandSurfaceKHR>(dlsym(libvulkan, "vkCreateWaylandSurfaceKHR")); // vkCreateWaylandSurfaceKHR = reinterpret_cast<PFN_vkCreateWaylandSurfaceKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateWaylandSurfaceKHR"));
// vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")); // vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
#endif #endif
#ifdef VK_USE_PLATFORM_MIR_KHR #ifdef VK_USE_PLATFORM_MIR_KHR
// vkCreateMirSurfaceKHR = reinterpret_cast<PFN_vkCreateMirSurfaceKHR>(dlsym(libvulkan, "vkCreateMirSurfaceKHR")); // vkCreateMirSurfaceKHR = reinterpret_cast<PFN_vkCreateMirSurfaceKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateMirSurfaceKHR"));
// vkGetPhysicalDeviceMirPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceMirPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceMirPresentationSupportKHR")); // vkGetPhysicalDeviceMirPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceMirPresentationSupportKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceMirPresentationSupportKHR"));
#endif #endif
#ifdef VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR
// vkCreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(dlsym(libvulkan, "vkCreateAndroidSurfaceKHR")); // vkCreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateAndroidSurfaceKHR"));
#endif #endif
#ifdef VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR
// vkCreateWin32SurfaceKHR = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(dlsym(libvulkan, "vkCreateWin32SurfaceKHR")); // vkCreateWin32SurfaceKHR = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(vkGetInstanceProcAddr(nullptr, "vkCreateWin32SurfaceKHR"));
// vkGetPhysicalDeviceWin32PresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceWin32PresentationSupportKHR")); // vkGetPhysicalDeviceWin32PresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(vkGetInstanceProcAddr(nullptr, "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
#endif #endif
#ifdef USE_DEBUG_EXTENTIONS #ifdef USE_DEBUG_EXTENTIONS
vkCreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(dlsym(libvulkan, "vkCreateDebugReportCallbackEXT")); vkCreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(vkGetInstanceProcAddr(nullptr, "vkCreateDebugReportCallbackEXT"));
vkDestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(dlsym(libvulkan, "vkDestroyDebugReportCallbackEXT")); vkDestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(vkGetInstanceProcAddr(nullptr, "vkDestroyDebugReportCallbackEXT"));
vkDebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(dlsym(libvulkan, "vkDebugReportMessageEXT")); vkDebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(vkGetInstanceProcAddr(nullptr, "vkDebugReportMessageEXT"));
#endif #endif
return SUPPORTED; return SUPPORTED;
} }

314
myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.h
View File

@ -22,166 +22,166 @@ bool IsVulkanSupported();
extern PFN_vkCreateInstance vkCreateInstance; extern PFN_vkCreateInstance vkCreateInstance;
extern PFN_vkDestroyInstance vkDestroyInstance; extern PFN_vkDestroyInstance vkDestroyInstance;
extern PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices; extern PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures; //extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties; //extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties; //extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties; //extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; //extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr; extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
extern PFN_vkCreateDevice vkCreateDevice; //extern PFN_vkCreateDevice vkCreateDevice;
extern PFN_vkDestroyDevice vkDestroyDevice; //extern PFN_vkDestroyDevice vkDestroyDevice;
extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties; //extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties; //extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; //extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties; //extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
extern PFN_vkGetDeviceQueue vkGetDeviceQueue; //extern PFN_vkGetDeviceQueue vkGetDeviceQueue;
extern PFN_vkQueueSubmit vkQueueSubmit; //extern PFN_vkQueueSubmit vkQueueSubmit;
extern PFN_vkQueueWaitIdle vkQueueWaitIdle; //extern PFN_vkQueueWaitIdle vkQueueWaitIdle;
extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle; //extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
extern PFN_vkAllocateMemory vkAllocateMemory; //extern PFN_vkAllocateMemory vkAllocateMemory;
extern PFN_vkFreeMemory vkFreeMemory; //extern PFN_vkFreeMemory vkFreeMemory;
extern PFN_vkMapMemory vkMapMemory; //extern PFN_vkMapMemory vkMapMemory;
extern PFN_vkUnmapMemory vkUnmapMemory; //extern PFN_vkUnmapMemory vkUnmapMemory;
extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges; //extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges; //extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment; //extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
extern PFN_vkBindBufferMemory vkBindBufferMemory; //extern PFN_vkBindBufferMemory vkBindBufferMemory;
extern PFN_vkBindImageMemory vkBindImageMemory; //extern PFN_vkBindImageMemory vkBindImageMemory;
extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; //extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; //extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements; //extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties; //extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties;
extern PFN_vkQueueBindSparse vkQueueBindSparse; //extern PFN_vkQueueBindSparse vkQueueBindSparse;
extern PFN_vkCreateFence vkCreateFence; //extern PFN_vkCreateFence vkCreateFence;
extern PFN_vkDestroyFence vkDestroyFence; //extern PFN_vkDestroyFence vkDestroyFence;
extern PFN_vkResetFences vkResetFences; //extern PFN_vkResetFences vkResetFences;
extern PFN_vkGetFenceStatus vkGetFenceStatus; //extern PFN_vkGetFenceStatus vkGetFenceStatus;
extern PFN_vkWaitForFences vkWaitForFences; //extern PFN_vkWaitForFences vkWaitForFences;
extern PFN_vkCreateSemaphore vkCreateSemaphore; //extern PFN_vkCreateSemaphore vkCreateSemaphore;
extern PFN_vkDestroySemaphore vkDestroySemaphore; //extern PFN_vkDestroySemaphore vkDestroySemaphore;
extern PFN_vkCreateEvent vkCreateEvent; //extern PFN_vkCreateEvent vkCreateEvent;
extern PFN_vkDestroyEvent vkDestroyEvent; //extern PFN_vkDestroyEvent vkDestroyEvent;
extern PFN_vkGetEventStatus vkGetEventStatus; //extern PFN_vkGetEventStatus vkGetEventStatus;
extern PFN_vkSetEvent vkSetEvent; //extern PFN_vkSetEvent vkSetEvent;
extern PFN_vkResetEvent vkResetEvent; //extern PFN_vkResetEvent vkResetEvent;
extern PFN_vkCreateQueryPool vkCreateQueryPool; //extern PFN_vkCreateQueryPool vkCreateQueryPool;
extern PFN_vkDestroyQueryPool vkDestroyQueryPool; //extern PFN_vkDestroyQueryPool vkDestroyQueryPool;
extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults; //extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
extern PFN_vkCreateBuffer vkCreateBuffer; //extern PFN_vkCreateBuffer vkCreateBuffer;
extern PFN_vkDestroyBuffer vkDestroyBuffer; //extern PFN_vkDestroyBuffer vkDestroyBuffer;
extern PFN_vkCreateBufferView vkCreateBufferView; //extern PFN_vkCreateBufferView vkCreateBufferView;
extern PFN_vkDestroyBufferView vkDestroyBufferView; //extern PFN_vkDestroyBufferView vkDestroyBufferView;
extern PFN_vkCreateImage vkCreateImage; //extern PFN_vkCreateImage vkCreateImage;
extern PFN_vkDestroyImage vkDestroyImage; //extern PFN_vkDestroyImage vkDestroyImage;
extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout; //extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
extern PFN_vkCreateImageView vkCreateImageView; //extern PFN_vkCreateImageView vkCreateImageView;
extern PFN_vkDestroyImageView vkDestroyImageView; //extern PFN_vkDestroyImageView vkDestroyImageView;
extern PFN_vkCreateShaderModule vkCreateShaderModule; //extern PFN_vkCreateShaderModule vkCreateShaderModule;
extern PFN_vkDestroyShaderModule vkDestroyShaderModule; //extern PFN_vkDestroyShaderModule vkDestroyShaderModule;
extern PFN_vkCreatePipelineCache vkCreatePipelineCache; //extern PFN_vkCreatePipelineCache vkCreatePipelineCache;
extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache; //extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData; //extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
extern PFN_vkMergePipelineCaches vkMergePipelineCaches; //extern PFN_vkMergePipelineCaches vkMergePipelineCaches;
extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines; //extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
extern PFN_vkCreateComputePipelines vkCreateComputePipelines; //extern PFN_vkCreateComputePipelines vkCreateComputePipelines;
extern PFN_vkDestroyPipeline vkDestroyPipeline; //extern PFN_vkDestroyPipeline vkDestroyPipeline;
extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout; //extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout; //extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
extern PFN_vkCreateSampler vkCreateSampler; //extern PFN_vkCreateSampler vkCreateSampler;
extern PFN_vkDestroySampler vkDestroySampler; //extern PFN_vkDestroySampler vkDestroySampler;
extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout; //extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout; //extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool; //extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool; //extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
extern PFN_vkResetDescriptorPool vkResetDescriptorPool; //extern PFN_vkResetDescriptorPool vkResetDescriptorPool;
extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets; //extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets; //extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets; //extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
extern PFN_vkCreateFramebuffer vkCreateFramebuffer; //extern PFN_vkCreateFramebuffer vkCreateFramebuffer;
extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer; //extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
extern PFN_vkCreateRenderPass vkCreateRenderPass; //extern PFN_vkCreateRenderPass vkCreateRenderPass;
extern PFN_vkDestroyRenderPass vkDestroyRenderPass; //extern PFN_vkDestroyRenderPass vkDestroyRenderPass;
extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity; //extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
extern PFN_vkCreateCommandPool vkCreateCommandPool; //extern PFN_vkCreateCommandPool vkCreateCommandPool;
extern PFN_vkDestroyCommandPool vkDestroyCommandPool; //extern PFN_vkDestroyCommandPool vkDestroyCommandPool;
extern PFN_vkResetCommandPool vkResetCommandPool; //extern PFN_vkResetCommandPool vkResetCommandPool;
extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; //extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers; //extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer; //extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
extern PFN_vkEndCommandBuffer vkEndCommandBuffer; //extern PFN_vkEndCommandBuffer vkEndCommandBuffer;
extern PFN_vkResetCommandBuffer vkResetCommandBuffer; //extern PFN_vkResetCommandBuffer vkResetCommandBuffer;
extern PFN_vkCmdBindPipeline vkCmdBindPipeline; //extern PFN_vkCmdBindPipeline vkCmdBindPipeline;
extern PFN_vkCmdSetViewport vkCmdSetViewport; //extern PFN_vkCmdSetViewport vkCmdSetViewport;
extern PFN_vkCmdSetScissor vkCmdSetScissor; //extern PFN_vkCmdSetScissor vkCmdSetScissor;
extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth; //extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias; //extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants; //extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds; //extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask; //extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask; //extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference; //extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets; //extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer; //extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers; //extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
extern PFN_vkCmdDraw vkCmdDraw; //extern PFN_vkCmdDraw vkCmdDraw;
extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed; //extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect; //extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect; //extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
extern PFN_vkCmdDispatch vkCmdDispatch; //extern PFN_vkCmdDispatch vkCmdDispatch;
extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect; //extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer; //extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
extern PFN_vkCmdCopyImage vkCmdCopyImage; //extern PFN_vkCmdCopyImage vkCmdCopyImage;
extern PFN_vkCmdBlitImage vkCmdBlitImage; //extern PFN_vkCmdBlitImage vkCmdBlitImage;
extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage; //extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer; //extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer; //extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
extern PFN_vkCmdFillBuffer vkCmdFillBuffer; //extern PFN_vkCmdFillBuffer vkCmdFillBuffer;
extern PFN_vkCmdClearColorImage vkCmdClearColorImage; //extern PFN_vkCmdClearColorImage vkCmdClearColorImage;
extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage; //extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
extern PFN_vkCmdClearAttachments vkCmdClearAttachments; //extern PFN_vkCmdClearAttachments vkCmdClearAttachments;
extern PFN_vkCmdResolveImage vkCmdResolveImage; //extern PFN_vkCmdResolveImage vkCmdResolveImage;
extern PFN_vkCmdSetEvent vkCmdSetEvent; //extern PFN_vkCmdSetEvent vkCmdSetEvent;
extern PFN_vkCmdResetEvent vkCmdResetEvent; //extern PFN_vkCmdResetEvent vkCmdResetEvent;
extern PFN_vkCmdWaitEvents vkCmdWaitEvents; //extern PFN_vkCmdWaitEvents vkCmdWaitEvents;
extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; //extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
extern PFN_vkCmdBeginQuery vkCmdBeginQuery; //extern PFN_vkCmdBeginQuery vkCmdBeginQuery;
extern PFN_vkCmdEndQuery vkCmdEndQuery; //extern PFN_vkCmdEndQuery vkCmdEndQuery;
extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool; //extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp; //extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults; //extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
extern PFN_vkCmdPushConstants vkCmdPushConstants; //extern PFN_vkCmdPushConstants vkCmdPushConstants;
extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass; //extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
extern PFN_vkCmdNextSubpass vkCmdNextSubpass; //extern PFN_vkCmdNextSubpass vkCmdNextSubpass;
extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass; //extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands; //extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
//
// VK_KHR_surface //// VK_KHR_surface
extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR; //extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR; //extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR; //extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR; //extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR; //extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
//
// VK_KHR_swapchain //// VK_KHR_swapchain
extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR; //extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; //extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; //extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR; //extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
extern PFN_vkQueuePresentKHR vkQueuePresentKHR; //extern PFN_vkQueuePresentKHR vkQueuePresentKHR;
//
// VK_KHR_display //// VK_KHR_display
extern PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR; //extern PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR;
extern PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR; //extern PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
extern PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR; //extern PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR;
extern PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR; //extern PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR;
extern PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR; //extern PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR;
extern PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR; //extern PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR;
extern PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR; //extern PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR;
//
// VK_KHR_display_swapchain //// VK_KHR_display_swapchain
extern PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR; //extern PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR;
#ifdef VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR
// VK_KHR_xlib_surface // VK_KHR_xlib_surface

12
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/AndInfo.kt
View File

@ -8,6 +8,9 @@ import com.xyzshell.andinfo.libs.SensorInfo
import com.xyzshell.andinfo.libs.BuildInfo import com.xyzshell.andinfo.libs.BuildInfo
import com.xyzshell.andinfo.libs.GpuInfo import com.xyzshell.andinfo.libs.GpuInfo
import com.xyzshell.andinfo.libs.InputInfo import com.xyzshell.andinfo.libs.InputInfo
import com.xyzshell.andinfo.libs.CameraInfo
import com.xyzshell.andinfo.libs.BluetoothInfo
import com.xyzshell.andinfo.libs.StorageInfo
class AndInfo private constructor(private val applicationContext: Context) { class AndInfo private constructor(private val applicationContext: Context) {
@ -34,6 +37,9 @@ class AndInfo private constructor(private val applicationContext: Context) {
private val _build: BuildInfo private val _build: BuildInfo
private val _gpu: GpuInfo private val _gpu: GpuInfo
private val _input: InputInfo private val _input: InputInfo
private val _camera: CameraInfo
private val _bluetooth: BluetoothInfo
private val _storage: StorageInfo
init { init {
_cpu = CpuInfo() _cpu = CpuInfo()
@ -43,6 +49,9 @@ class AndInfo private constructor(private val applicationContext: Context) {
_build = BuildInfo(applicationContext) _build = BuildInfo(applicationContext)
_gpu = GpuInfo(applicationContext) _gpu = GpuInfo(applicationContext)
_input = InputInfo(applicationContext) _input = InputInfo(applicationContext)
_camera = CameraInfo(applicationContext)
_bluetooth = BluetoothInfo(applicationContext)
_storage = StorageInfo(applicationContext)
} }
val cpu get() = _cpu val cpu get() = _cpu
@ -52,6 +61,9 @@ class AndInfo private constructor(private val applicationContext: Context) {
val build get() = _build val build get() = _build
val gpu get() = _gpu val gpu get() = _gpu
val input get() = _input val input get() = _input
val camera get() = _camera
val bluetooth get() = _bluetooth
val storage get() = _storage
val context get() = applicationContext val context get() = applicationContext

45
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/BluetoothInfo.kt Normal file
View File

@ -0,0 +1,45 @@
package com.xyzshell.andinfo.libs
import android.Manifest
import android.annotation.SuppressLint
import android.bluetooth.BluetoothManager
import android.content.Context
import android.content.pm.PackageManager
import android.os.Build
class BluetoothInfo(private val context: Context) {
private val bluetoothManager: BluetoothManager? = context.getSystemService(
BluetoothManager::class.java
)
@get:SuppressLint("MissingPermission")
val bluetoothAdapter by lazy { bluetoothManager?.adapter }
@get:SuppressLint("MissingPermission")
val adapterName: String?
get() = bluetoothAdapter?.name
@get:SuppressLint("HardwareIds", "MissingPermission")
val adapterMacAddress: String?
get() = bluetoothAdapter?.address
@get:SuppressLint("MissingPermission")
val bondedDevices: List<Pair<String?, String>>
get() = bluetoothAdapter?.bondedDevices?.map {
Pair(it.name, it.address)
} ?: emptyList()
val isBluetoothLeSupported: Boolean
get() = context.packageManager.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)
val requiredPermissions: Array<String>
get() = buildList {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
add(Manifest.permission.BLUETOOTH_CONNECT)
} else {
add(Manifest.permission.BLUETOOTH)
add(Manifest.permission.BLUETOOTH_ADMIN)
}
}.toTypedArray()
}

114
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/CameraInfo.kt Normal file
View File

@ -0,0 +1,114 @@
package com.xyzshell.andinfo.libs
import android.Manifest
import android.content.Context
import android.hardware.camera2.CameraCharacteristics
import android.hardware.camera2.CameraManager
import android.hardware.camera2.CameraMetadata
import android.os.Build
import android.os.Handler
import android.os.Looper
import com.xyzshell.andinfo.R
import com.xyzshell.andinfo.libs.camera.models.CameraCapability
import com.xyzshell.andinfo.libs.camera.models.CameraFacing
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.callbackFlow
class CameraInfo(private val context: Context) {
private val cameraManager: CameraManager? = context.getSystemService(
CameraManager::class.java
)
val cameraIds: List<String>
get() = cameraManager?.cameraIdList?.toList() ?: emptyList()
fun getCameraCharacteristics(cameraId: String): CameraCharacteristics? {
return cameraManager?.getCameraCharacteristics(cameraId)
}
fun cameraIdsFlow() = cameraManager?.let { manager ->
callbackFlow {
val onCameraIdUpdated = {
trySend(manager.cameraIdList.toList())
}
val availabilityCallback = object : CameraManager.AvailabilityCallback() {
override fun onCameraAvailable(cameraId: String) {
onCameraIdUpdated()
}
override fun onCameraUnavailable(cameraId: String) {
onCameraIdUpdated()
}
}
manager.registerAvailabilityCallback(
availabilityCallback, Handler(Looper.getMainLooper())
)
onCameraIdUpdated()
awaitClose {
manager.unregisterAvailabilityCallback(availabilityCallback)
}
}
}
fun getCameraFacing(characteristics: CameraCharacteristics): CameraFacing? {
return characteristics.get(CameraCharacteristics.LENS_FACING)?.let {
when (it) {
CameraMetadata.LENS_FACING_BACK -> CameraFacing.BACK
CameraMetadata.LENS_FACING_FRONT -> CameraFacing.FRONT
CameraMetadata.LENS_FACING_EXTERNAL -> CameraFacing.EXTERNAL
else -> null
}
}
}
fun getPixelArraySize(characteristics: CameraCharacteristics): String? {
return characteristics.get(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE)?.toString()
}
fun getSensorPhysicalSize(characteristics: CameraCharacteristics): String? {
return characteristics.get(CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE)?.toString()
}
fun hasFlashUnit(characteristics: CameraCharacteristics): Boolean? {
return characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE)
}
fun getAvailableApertures(characteristics: CameraCharacteristics): FloatArray? {
return characteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_APERTURES)
}
fun getAvailableCapabilities(characteristics: CameraCharacteristics): List<CameraCapability> {
val capabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)
return capabilities?.toList()?.mapNotNull { capability ->
when (capability) {
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE -> CameraCapability.BACKWARD_COMPATIBLE
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR -> CameraCapability.MANUAL_SENSOR
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING -> CameraCapability.MANUAL_POST_PROCESSING
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW -> CameraCapability.RAW
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING -> CameraCapability.PRIVATE_REPROCESSING
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS -> CameraCapability.READ_SENSOR_SETTINGS
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE -> CameraCapability.BURST_CAPTURE
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING -> CameraCapability.YUV_REPROCESSING
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT -> CameraCapability.DEPTH_OUTPUT
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO -> CameraCapability.CONSTRAINED_HIGH_SPEED_VIDEO
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) CameraCapability.MOTION_TRACKING else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) CameraCapability.LOGICAL_MULTI_CAMERA else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) CameraCapability.MONOCHROME else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) CameraCapability.SECURE_IMAGE_DATA else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_SYSTEM_CAMERA -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) CameraCapability.SYSTEM_CAMERA else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) CameraCapability.OFFLINE_PROCESSING else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_ULTRA_HIGH_RESOLUTION_SENSOR -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) CameraCapability.ULTRA_HIGH_RESOLUTION_SENSOR else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_REMOSAIC_REPROCESSING -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) CameraCapability.REMOSAIC_REPROCESSING else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) CameraCapability.DYNAMIC_RANGE_TEN_BIT else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) CameraCapability.STREAM_USE_CASE else null
CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_COLOR_SPACE_PROFILES -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) CameraCapability.COLOR_SPACE_PROFILES else null
else -> null
}
} ?: emptyList()
}
}

92
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/StorageInfo.kt Normal file
View File

@ -0,0 +1,92 @@
package com.xyzshell.andinfo.libs
import android.content.Context
import android.os.Environment
import android.os.StatFs
import com.xyzshell.andinfo.libs.storage.models.EncryptionType
import com.xyzshell.andinfo.utils.SystemProperties
class StorageInfo(private val context: Context) {
val internalStorageTotalSpace: Long
get() = StatFs(Environment.getDataDirectory().absolutePath).let { statFs ->
statFs.blockCountLong * statFs.blockSizeLong
}
val internalStorageAvailableSpace: Long
get() = StatFs(Environment.getDataDirectory().absolutePath).let { statFs ->
statFs.availableBlocksLong * statFs.blockSizeLong
}
val internalStorageUsedSpace: Long
get() = internalStorageTotalSpace - internalStorageAvailableSpace
val isInternalStorageEncrypted: Boolean?
get() = when (SystemProperties.getString("ro.crypto.state", "unknown")) {
"encrypted" -> true
"unencrypted" -> false
else -> null
}
val internalStorageEncryptionType: EncryptionType?
get() = when (SystemProperties.getString("ro.crypto.type", "unknown")) {
"none" -> EncryptionType.NONE
"block" -> EncryptionType.FDE
"file" -> EncryptionType.FBE
else -> null
}
val externalStorageTotalSpace: Long?
get() = runCatching {
StatFs(Environment.getExternalStorageDirectory().absolutePath).let { statFs ->
statFs.blockCountLong * statFs.blockSizeLong
}
}.getOrNull()
val externalStorageAvailableSpace: Long?
get() = runCatching {
StatFs(Environment.getExternalStorageDirectory().absolutePath).let { statFs ->
statFs.availableBlocksLong * statFs.blockSizeLong
}
}.getOrNull()
val externalStorageUsedSpace: Long?
get() = externalStorageTotalSpace?.let { total ->
externalStorageAvailableSpace?.let { available ->
total - available
}
}
val isExternalStorageEmulated: Boolean
get() = Environment.isExternalStorageEmulated()
val isExternalStorageRemovable: Boolean
get() = Environment.isExternalStorageRemovable()
val hasUpdatableApex: Boolean?
get() = SystemProperties.getBoolean("ro.apex.updatable")
val usesSystemAsRoot: Boolean?
get() = SystemProperties.getBoolean("ro.build.system_root_image")
val usesAb: Boolean?
get() = SystemProperties.getBoolean("ro.build.ab_update")
val abOtaPartitions: Array<String>?
get() = SystemProperties.getString("ro.product.ab_ota_partitions")?.split(",")?.toTypedArray()
val usesDynamicPartitions: Boolean?
get() = SystemProperties.getBoolean("ro.boot.dynamic_partitions")
val usesRetrofittedDynamicPartitions: Boolean?
get() = SystemProperties.getBoolean("ro.boot.dynamic_partitions_retrofit")
val usesVirtualAb: Boolean?
get() = SystemProperties.getBoolean("ro.virtual_ab.enabled")
val usesRetrofittedVirtualAb: Boolean?
get() = SystemProperties.getBoolean("ro.virtual_ab.retrofit")
val usesCompressedVirtualAb: Boolean?
get() = SystemProperties.getBoolean("ro.virtual_ab.compression.enabled")
}

31
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/camera/models/CameraModels.kt Normal file
View File

@ -0,0 +1,31 @@
package com.xyzshell.andinfo.libs.camera.models
enum class CameraFacing {
BACK,
FRONT,
EXTERNAL
}
enum class CameraCapability {
BACKWARD_COMPATIBLE,
MANUAL_SENSOR,
MANUAL_POST_PROCESSING,
RAW,
PRIVATE_REPROCESSING,
READ_SENSOR_SETTINGS,
BURST_CAPTURE,
YUV_REPROCESSING,
DEPTH_OUTPUT,
CONSTRAINED_HIGH_SPEED_VIDEO,
MOTION_TRACKING,
LOGICAL_MULTI_CAMERA,
MONOCHROME,
SECURE_IMAGE_DATA,
SYSTEM_CAMERA,
OFFLINE_PROCESSING,
ULTRA_HIGH_RESOLUTION_SENSOR,
REMOSAIC_REPROCESSING,
DYNAMIC_RANGE_TEN_BIT,
STREAM_USE_CASE,
COLOR_SPACE_PROFILES
}

6
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDevice.kt
View File

@ -2,10 +2,10 @@ package com.xyzshell.andinfo.libs.gpu.models
data class VkPhysicalDevice( data class VkPhysicalDevice(
val apiVersion: VkVersion, val apiVersion: VkVersion,
val driverVersion: Int, val driverVersion: Long,
val vendorId: Int, val vendorId: Long,
val registeredVendorId: VkVendorId?, val registeredVendorId: VkVendorId?,
val deviceId: Int, val deviceId: Long,
val deviceType: VkPhysicalDeviceType, val deviceType: VkPhysicalDeviceType,
val deviceName: String, val deviceName: String,
) )

4
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDeviceType.kt
View File

@ -1,6 +1,6 @@
package com.xyzshell.andinfo.libs.gpu.models package com.xyzshell.andinfo.libs.gpu.models
enum class VkPhysicalDeviceType(val value: Int) { enum class VkPhysicalDeviceType(val value: Long) {
OTHER(0), OTHER(0),
INTEGRATED_GPU(1), INTEGRATED_GPU(1),
DISCRETE_GPU(2), DISCRETE_GPU(2),
@ -9,6 +9,6 @@ enum class VkPhysicalDeviceType(val value: Int) {
; ;
companion object { companion object {
fun fromValue(value: Int) = values().firstOrNull { it.value == value } fun fromValue(value: Long) = values().firstOrNull { it.value == value }
} }
} }

4
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkVendorId.kt
View File

@ -1,6 +1,6 @@
package com.xyzshell.andinfo.libs.gpu.models package com.xyzshell.andinfo.libs.gpu.models
enum class VkVendorId(val id: Int) { enum class VkVendorId(val id: Long) {
KHRONOS(0x10001), KHRONOS(0x10001),
VIV(0x10002), VIV(0x10002),
VSI(0x10003), VSI(0x10003),
@ -12,6 +12,6 @@ enum class VkVendorId(val id: Int) {
; ;
companion object { companion object {
fun fromId(id: Int) = values().firstOrNull { it.id == id } fun fromId(id: Long) = values().firstOrNull { it.id == id }
} }
} }

8
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/utils/VkUtils.kt
View File

@ -14,14 +14,14 @@ object VkUtils {
fun addDevice( fun addDevice(
apiVersion: Long, apiVersion: Long,
driverVersion: Long, driverVersion: Long,
vendorId: Int, vendorId: Long,
deviceId: Int, deviceId: Long,
deviceType: Int, deviceType: Long,
deviceName: String, deviceName: String,
) = add( ) = add(
VkPhysicalDevice( VkPhysicalDevice(
apiVersion = VkVersion(apiVersion.toInt()), apiVersion = VkVersion(apiVersion.toInt()),
driverVersion = driverVersion.toInt(), driverVersion = driverVersion,
vendorId = vendorId, vendorId = vendorId,
registeredVendorId = com.xyzshell.andinfo.libs.gpu.models.VkVendorId.fromId(vendorId), registeredVendorId = com.xyzshell.andinfo.libs.gpu.models.VkVendorId.fromId(vendorId),
deviceId = deviceId, deviceId = deviceId,

7
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/storage/models/EncryptionType.kt Normal file
View File

@ -0,0 +1,7 @@
package com.xyzshell.andinfo.libs.storage.models
enum class EncryptionType {
NONE,
FDE,
FBE
}

196
myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/utils/SystemProperties.kt Normal file
View File

@ -0,0 +1,196 @@
package com.xyzshell.andinfo.utils
import android.os.Build
import android.util.Log
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.regex.Pattern
object SystemProperties {
private const val LOG_TAG = "SystemProperties"
/**
* From system/libbase/parsebool.cpp
*/
private val YES_VALUES = setOf(
"1",
"y",
"yes",
"on",
"true",
)
/**
* From system/libbase/parsebool.cpp
*/
private val NO_VALUES = setOf(
"0",
"n",
"no",
"off",
"false",
)
private abstract class Provider {
/**
* Return whether or not the implementation works.
*/
abstract fun isValid(): Boolean
/**
* Get a string property.
* Implementation must do everything possible to figure out if the property exists
* (empty string is considered existing).
*
* @param key The property key
* @return The property value or null if it doesn't exist
*/
abstract fun getString(key: String): String?
}
@Suppress("PrivateApi")
private object SystemPropertiesReflectionProvider : Provider() {
private const val CLASS_NAME = "android.os.SystemProperties"
private const val DEFAULT = "default"
private const val ALT_DEFAULT = "alt_default"
private val systemPropertiesClass = runCatching {
Class.forName(CLASS_NAME)
}.onFailure {
Log.e(LOG_TAG, "Failed to get $CLASS_NAME", it)
}.getOrNull()
private val _getMethod = runCatching {
systemPropertiesClass?.getMethod(
"get", String::class.java, String::class.java
)
}.getOrNull()
private val getMethod get() = _getMethod!!
override fun isValid() = listOf(
systemPropertiesClass,
_getMethod,
).all { it != null }
override fun getString(key: String): String? {
val key = when (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
true -> key
false -> key.take(31)
}
val value = getMethod.invoke(systemPropertiesClass, key, DEFAULT) as String
val altValue = getMethod.invoke(systemPropertiesClass, key, ALT_DEFAULT) as String
return value.takeIf {
// If both values stays the same when changing default value, something is set
// and the value didn't change between the calls
it == altValue
} ?: when (value == DEFAULT && altValue == ALT_DEFAULT) {
true -> null // Both are equal to the defaults
false -> {
// Let's just repeat the process, we checked at a bad time
getString(key)
}
}
}
}
private object GetPropProvider : Provider() {
private const val GETPROP_EXECUTABLE_PATH = "/system/bin/getprop"
private val GETPROP_LINE_PATTERN = Pattern.compile("\\[(.*?)]: \\[(.*?)]")
override fun isValid() = true
override fun getString(key: String) = getProps()[key]
fun getProps() = mutableMapOf<String, String>().apply {
var process: Process? = null
try {
process = ProcessBuilder()
.command(GETPROP_EXECUTABLE_PATH)
.redirectErrorStream(true)
.start()
process?.let { p ->
BufferedReader(InputStreamReader(p.inputStream)).forEachLine { line ->
val matcher = GETPROP_LINE_PATTERN.matcher(line)
if (matcher.find()) {
matcher.group(1)?.let { key ->
this[key] = matcher.group(2) ?: ""
}
}
}
}
} catch (e: Exception) {
Log.e(LOG_TAG, "Failed to read system properties: $e")
} finally {
process?.destroy()
}
}.toMap()
}
private object DummyProvider : Provider() {
override fun isValid() = true
override fun getString(key: String) = null
}
private val provider = listOf(
SystemPropertiesReflectionProvider,
GetPropProvider,
).firstOrNull {
it.isValid()
} ?: run {
Log.e(LOG_TAG, "No working system properties provider found")
DummyProvider
}
fun getProps() = GetPropProvider.getProps()
fun getString(key: String) = provider.getString(key)
fun getString(key: String, default: String) = getString(key) ?: default
fun getInt(key: String) = provider.getString(key)?.let { parseNumber(it, String::toIntOrNull) }
fun getInt(key: String, default: Int) = getInt(key) ?: default
fun getLong(key: String) =
provider.getString(key)?.let { parseNumber(it, String::toLongOrNull) }
fun getLong(key: String, default: Long) = getLong(key) ?: default
fun getBoolean(key: String) = getString(key)?.let {
when {
YES_VALUES.contains(it) -> true
NO_VALUES.contains(it) -> false
else -> null
}
}
fun getBoolean(key: String, default: Boolean) = getBoolean(key) ?: default
private inline fun <reified T : Number> parseNumber(
value: String, toTOrNull: String.(radix: Int) -> T?
): T? {
val trimmedValue = value.trimStart()
if (trimmedValue.isEmpty()) {
return null
}
val isHex = trimmedValue.length > 2
&& trimmedValue[0] == '0'
&& trimmedValue[1] in listOf('x', 'X')
val radix = when (isHex) {
true -> 16
false -> 10
}
return trimmedValue.toTOrNull(radix)
}
}

70
myphoneinfo/andinfo/src/main/res/values/strings.xml Normal file
View File

@ -0,0 +1,70 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="section_camera_name">相机</string>
<string name="section_camera_description">显示相机信息</string>
<string name="camera_title">%1$s 相机</string>
<string name="camera_facing">朝向</string>
<string name="camera_pixel_array_size">像素阵列大小</string>
<string name="camera_sensor_physical_size">传感器物理尺寸</string>
<string name="camera_has_flash_unit">有闪光灯</string>
<string name="camera_available_apertures">可用光圈</string>
<string name="camera_available_capablities">可用功能</string>
<string name="camera_facing_back">后置</string>
<string name="camera_facing_front">前置</string>
<string name="camera_facing_external">外置</string>
<string name="camera_capabilities_backward_compatible">向后兼容</string>
<string name="camera_capabilities_manual_sensor">手动传感器</string>
<string name="camera_capabilities_manual_post_processing">手动后期处理</string>
<string name="camera_capabilities_raw">RAW</string>
<string name="camera_capabilities_private_reprocessing">私有再处理</string>
<string name="camera_capabilities_read_sensor_settings">读取传感器设置</string>
<string name="camera_capabilities_burst_capture">连拍</string>
<string name="camera_capabilities_yuv_reprocessing">YUV 再处理</string>
<string name="camera_capabilities_depth_output">深度输出</string>
<string name="camera_capabilities_constrained_high_speed_video">受限高速视频</string>
<string name="camera_capabilities_motion_tracking">运动追踪</string>
<string name="camera_capabilities_logical_multi_camera">逻辑多相机</string>
<string name="camera_capabilities_monochrome">单色</string>
<string name="camera_capabilities_secure_image_data">安全图像数据</string>
<string name="camera_capabilities_system_camera">系统相机</string>
<string name="camera_capabilities_offline_processing">离线处理</string>
<string name="camera_capabilities_ultra_high_resolution_sensor">超高分辨率传感器</string>
<string name="camera_capabilities_remosaic_processing">重镶嵌处理</string>
<string name="camera_capabilities_dynamic_range_ten_bit">动态范围十位</string>
<string name="camera_capabilities_stream_use_case">流用例</string>
<string name="camera_capabilities_color_space_profiles">色彩空间配置文件</string>
<string name="section_bluetooth_name">蓝牙</string>
<string name="section_bluetooth_description">显示蓝牙信息</string>
<string name="bluetooth_adapter">适配器</string>
<string name="bluetooth_adapter_name">名称</string>
<string name="bluetooth_adapter_mac_address">MAC 地址</string>
<string name="bluetooth_bonded_devices">已配对设备</string>
<string name="bluetooth_le">低功耗蓝牙</string>
<string name="bluetooth_le_supported">支持</string>
<string name="section_storage_name">存储</string>
<string name="section_storage_description">显示存储信息</string>
<string name="storage_internal_storage">内部存储</string>
<string name="storage_total_space">总空间</string>
<string name="storage_available_space">可用空间</string>
<string name="storage_used_space">已用空间</string>
<string name="storage_is_encrypted">已加密</string>
<string name="storage_encryption_type">加密类型</string>
<string name="storage_external_storage">外部存储</string>
<string name="storage_is_emulated">已模拟</string>
<string name="storage_is_removable">可移除</string>
<string name="storage_system_partitions">系统分区</string>
<string name="storage_has_updatable_apex">有可更新的 APEX</string>
<string name="storage_uses_system_as_root">使用 system-as-root</string>
<string name="storage_uses_ab">使用 A/B 更新</string>
<string name="storage_ab_ota_partitions">A/B OTA 分区</string>
<string name="storage_uses_dynamic_partitions">使用动态分区</string>
<string name="storage_uses_retrofitted_dynamic_partitions">使用改造的动态分区</string>
<string name="storage_uses_virtual_ab">使用虚拟 A/B</string>
<string name="storage_uses_retrofitted_virtual_ab">使用改造的虚拟 A/B</string>
<string name="storage_uses_compressed_virtual_ab">使用压缩的虚拟 A/B</string>
<string name="encryption_type_none">无</string>
<string name="encryption_type_fde">全盘加密 (FDE)</string>
<string name="encryption_type_fbe">文件级加密 (FBE)</string>
</resources>

266
myphoneinfo/src/main/java/com/xyzshell/myphoneinfo/MainActivity.kt
View File

@ -1,69 +1,50 @@
package com.xyzshell.myphoneinfo package com.xyzshell.myphoneinfo
import android.app.AlertDialog import android.Manifest
import android.content.pm.PackageManager
import android.hardware.Sensor
import android.os.Build
import android.os.Bundle import android.os.Bundle
import android.text.format.Formatter
import androidx.activity.ComponentActivity import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.background import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.layout.width import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.AlertDialog import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button import androidx.compose.material3.Button
import androidx.compose.material3.Card import androidx.compose.material3.Card
import androidx.compose.material3.ListItem
import androidx.compose.material3.Scaffold import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text import androidx.compose.material3.Text
import androidx.compose.material3.TextButton import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.tooling.preview.Preview import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import com.xyzshell.myphoneinfo.ui.theme.MyAndriodInfoTheme
import com.xyzshell.andinfo.AndInfo import com.xyzshell.andinfo.AndInfo
import android.text.format.Formatter
import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue
import android.hardware.Sensor
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.ListItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ModalBottomSheet
import androidx.compose.material3.rememberModalBottomSheetState
import androidx.compose.material3.SheetState
import androidx.compose.material3.rememberStandardBottomSheetState
import androidx.compose.material3.BottomSheetScaffold
import androidx.compose.material3.SheetValue
import androidx.compose.material3.rememberBottomSheetScaffoldState
import androidx.compose.material3.BottomSheetDefaults
import androidx.compose.material3.BottomSheetScaffoldState
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.rememberBottomSheetScaffoldState
import kotlinx.coroutines.launch
import androidx.compose.runtime.rememberCoroutineScope
import com.xyzshell.andinfo.libs.SensorInfo
import com.xyzshell.andinfo.libs.GpuInfo import com.xyzshell.andinfo.libs.GpuInfo
import com.xyzshell.andinfo.libs.gpu.models.VkPhysicalDevice
import com.xyzshell.andinfo.libs.gpu.models.EglInformation
import androidx.compose.foundation.lazy.itemsIndexed
import android.os.Build
import com.xyzshell.andinfo.libs.InputInfo import com.xyzshell.andinfo.libs.InputInfo
import com.xyzshell.andinfo.libs.InputInfo.InputDeviceInfo import com.xyzshell.andinfo.libs.InputInfo.InputDeviceInfo
import androidx.compose.foundation.clickable import com.xyzshell.andinfo.libs.SensorInfo
import com.xyzshell.myphoneinfo.ui.theme.MyAndriodInfoTheme
class MainActivity : ComponentActivity() { class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) { override fun onCreate(savedInstanceState: Bundle?) {
@ -73,15 +54,27 @@ class MainActivity : ComponentActivity() {
MyAndriodInfoTheme { MyAndriodInfoTheme {
Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding -> Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
MainView( MainView(
name = "DevCheck Clone", name = "DevCheck",
modifier = Modifier.padding(innerPadding) modifier = Modifier.padding(innerPadding)
) )
} }
} }
} }
requestBluetoothPermissionsIfNeeded()
} }
private fun requestBluetoothPermissionsIfNeeded() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
if (checkSelfPermission(Manifest.permission.BLUETOOTH_CONNECT)
!= PackageManager.PERMISSION_GRANTED
) {
requestPermissions(
arrayOf<String?>(Manifest.permission.BLUETOOTH_CONNECT),
1001
)
}
}
}
} }
@Composable @Composable
@ -95,18 +88,25 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
var showGpuDialog by remember { mutableStateOf(false) } var showGpuDialog by remember { mutableStateOf(false) }
var showInputDevicesDialog by remember { mutableStateOf(false) } var showInputDevicesDialog by remember { mutableStateOf(false) }
var selectedInputDevice by remember { mutableStateOf<InputDeviceInfo?>(null) } var selectedInputDevice by remember { mutableStateOf<InputDeviceInfo?>(null) }
var showCameraDialog by remember { mutableStateOf(false) }
var showBluetoothDialog by remember { mutableStateOf(false) }
var showStorageDialog by remember { mutableStateOf(false) }
Column (modifier){ Column (modifier.fillMaxWidth().verticalScroll(rememberScrollState())){
Box(modifier = Modifier.fillMaxWidth()){ Box(modifier = Modifier.fillMaxWidth()){
Text(text = name, Modifier.align(Alignment.Center)) Text(text = name, Modifier.align(Alignment.Center))
} }
Card(modifier= Modifier.fillMaxWidth().padding(10.dp)){ Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
Text("硬件：${AndInfo.instance.cpu.hardware()}") Text("硬件：${AndInfo.instance.cpu.hardware()}")
Text("核心数：${AndInfo.instance.cpu.cores.size}") Text("核心数：${AndInfo.instance.cpu.cores.size}")
Button(onClick = { showCpuDialog = true }) { Text("CPU 详情") } Button(onClick = { showCpuDialog = true }) { Text("CPU 详情") }
} }
Spacer(modifier = Modifier.height(16.dp)) Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier.fillMaxWidth().padding(10.dp)){ Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
val memoryInfo = AndInfo.instance.device.getMemoryInfo() val memoryInfo = AndInfo.instance.device.getMemoryInfo()
Text("设备型号：${AndInfo.instance.device.model}") Text("设备型号：${AndInfo.instance.device.model}")
Text("制造商：${AndInfo.instance.device.manufacturer}") Text("制造商：${AndInfo.instance.device.manufacturer}")
@ -115,7 +115,9 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
Button(onClick = { showDeviceDialog = true }) { Text("设备详情") } Button(onClick = { showDeviceDialog = true }) { Text("设备详情") }
} }
Spacer(modifier = Modifier.height(16.dp)) Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier.fillMaxWidth().padding(10.dp)){ Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
val defaultDisplayInfo = AndInfo.instance.display.getDefaultDisplayInfo() val defaultDisplayInfo = AndInfo.instance.display.getDefaultDisplayInfo()
if (defaultDisplayInfo != null) { if (defaultDisplayInfo != null) {
Text("显示器名称：${defaultDisplayInfo.name}") Text("显示器名称：${defaultDisplayInfo.name}")
@ -127,28 +129,36 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
} }
} }
Spacer(modifier = Modifier.height(16.dp)) Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier.fillMaxWidth().padding(10.dp)){ Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
val allSensors = AndInfo.instance.sensor.getAllSensors() val allSensors = AndInfo.instance.sensor.getAllSensors()
Text("传感器数量：${allSensors.size}") Text("传感器数量：${allSensors.size}")
Text("支持动态传感器发现：${AndInfo.instance.sensor.isDynamicSensorDiscoverySupported()}") Text("支持动态传感器发现：${AndInfo.instance.sensor.isDynamicSensorDiscoverySupported()}")
Button(onClick = { showSensorsDialog = true }) { Text("传感器列表") } Button(onClick = { showSensorsDialog = true }) { Text("传感器列表") }
} }
Spacer(modifier = Modifier.height(16.dp)) Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier.fillMaxWidth().padding(10.dp)){ Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
Text("构建指纹：${AndInfo.instance.build.fingerprint}") Text("构建指纹：${AndInfo.instance.build.fingerprint}")
Text("构建类型：${AndInfo.instance.build.type}") Text("构建类型：${AndInfo.instance.build.type}")
Text("Android 版本：${AndInfo.instance.build.versionRelease} (SDK ${AndInfo.instance.build.versionSdkInt})") Text("Android 版本：${AndInfo.instance.build.versionRelease} (SDK ${AndInfo.instance.build.versionSdkInt})")
Button(onClick = { showBuildDialog = true }) { Text("构建详情") } Button(onClick = { showBuildDialog = true }) { Text("构建详情") }
} }
Spacer(modifier = Modifier.height(16.dp)) Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier.fillMaxWidth().padding(10.dp)){ Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
val gpuInfo = AndInfo.instance.gpu.getGpuInformation() val gpuInfo = AndInfo.instance.gpu.getGpuInformation()
Text("Vulkan 设备数量：${gpuInfo.vkPhysicalDevices?.size ?: 0}") Text("Vulkan 设备数量：${gpuInfo.vkPhysicalDevices?.size ?: 0}")
Text("EGL 信息可用：${gpuInfo.eglInformation != null}") Text("EGL 信息可用：${gpuInfo.eglInformation != null}")
Button(onClick = { showGpuDialog = true }) { Text("GPU 详情") } Button(onClick = { showGpuDialog = true }) { Text("GPU 详情") }
} }
Spacer(modifier = Modifier.height(16.dp)) Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier.fillMaxWidth().padding(10.dp)){ Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
val inputDevices = AndInfo.instance.input.getInputDevices() val inputDevices = AndInfo.instance.input.getInputDevices()
Text("输入设备数量：${inputDevices.size}") Text("输入设备数量：${inputDevices.size}")
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
@ -159,6 +169,36 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
} }
Button(onClick = { showInputDevicesDialog = true }) { Text("输入设备列表") } Button(onClick = { showInputDevicesDialog = true }) { Text("输入设备列表") }
} }
Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
val cameraIds = AndInfo.instance.camera.cameraIds
Text("相机数量：${cameraIds.size}")
Button(onClick = { showCameraDialog = true }) { Text("相机详情") }
}
Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
val bluetoothAdapter = AndInfo.instance.bluetooth.bluetoothAdapter
Text("蓝牙适配器可用：${bluetoothAdapter != null}")
bluetoothAdapter?.let {
Text("适配器名称：${AndInfo.instance.bluetooth.adapterName ?: "N/A"}")
Text("已配对设备：${AndInfo.instance.bluetooth.bondedDevices.size}")
}
Button(onClick = { showBluetoothDialog = true }) { Text("蓝牙详情") }
}
Spacer(modifier = Modifier.height(16.dp))
Card(modifier= Modifier
.fillMaxWidth()
.padding(10.dp)){
val storageInfo = AndInfo.instance.storage
Text("内部存储总空间：${Formatter.formatFileSize(AndInfo.instance.context, storageInfo.internalStorageTotalSpace)}")
Text("内部存储可用空间：${Formatter.formatFileSize(AndInfo.instance.context, storageInfo.internalStorageAvailableSpace)}")
Text("外部存储可用：${storageInfo.externalStorageTotalSpace != null}")
Button(onClick = { showStorageDialog = true }) { Text("存储详情") }
}
} }
if (showCpuDialog) { if (showCpuDialog) {
@ -273,7 +313,8 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
headlineContent = { Text(sensor.name) }, headlineContent = { Text(sensor.name) },
supportingContent = { Text(sensor.stringType) }, supportingContent = { Text(sensor.stringType) },
trailingContent = { Text(sensor.vendor) }, trailingContent = { Text(sensor.vendor) },
modifier = Modifier.fillMaxWidth() modifier = Modifier
.fillMaxWidth()
.clickable { .clickable {
selectedSensor = sensor selectedSensor = sensor
showSensorsDialog = false showSensorsDialog = false
@ -462,7 +503,8 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
ListItem( ListItem(
headlineContent = { Text(inputDevice.name) }, headlineContent = { Text(inputDevice.name) },
supportingContent = { Text("ID: ${inputDevice.id}, 供应商: ${inputDevice.vendorId}, 产品: ${inputDevice.productId}") }, supportingContent = { Text("ID: ${inputDevice.id}, 供应商: ${inputDevice.vendorId}, 产品: ${inputDevice.productId}") },
modifier = Modifier.fillMaxWidth() modifier = Modifier
.fillMaxWidth()
.clickable { .clickable {
selectedInputDevice = inputDevice selectedInputDevice = inputDevice
showInputDevicesDialog = false showInputDevicesDialog = false
@ -510,6 +552,134 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
} }
) )
} }
if (showCameraDialog) {
val cameraInfo = AndInfo.instance.camera
val cameraIds = cameraInfo.cameraIds
AlertDialog(
onDismissRequest = { showCameraDialog = false },
title = { Text(text = "相机详情") },
text = {
LazyColumn {
if (cameraIds.isNotEmpty()) {
item { Text("相机数量: ${cameraIds.size}") }
items(cameraIds) { cameraId ->
val characteristics = cameraInfo.getCameraCharacteristics(cameraId)
characteristics?.let {
Column(modifier = Modifier.padding(start = 16.dp)) {
Text("相机 ID: $cameraId")
cameraInfo.getCameraFacing(it)?.let { facing ->
Text(" 朝向: $facing")
}
cameraInfo.getPixelArraySize(it)?.let { size ->
Text(" 像素阵列大小: $size")
}
cameraInfo.getSensorPhysicalSize(it)?.let { size ->
Text(" 传感器物理尺寸: $size")
}
cameraInfo.hasFlashUnit(it)?.let { hasFlash ->
Text(" 有闪光灯: $hasFlash")
}
cameraInfo.getAvailableApertures(it)?.let { apertures ->
Text(" 可用光圈: ${apertures.joinToString()}")
}
val capabilities = cameraInfo.getAvailableCapabilities(it)
if (capabilities.isNotEmpty()) {
Text(" 可用功能: ${capabilities.joinToString()}")
}
}
}
}
} else {
item { Text("无相机信息") }
}
}
},
confirmButton = {
TextButton(onClick = { showCameraDialog = false }) {
Text("确认")
}
}
)
}
if (showBluetoothDialog) {
val bluetoothInfo = AndInfo.instance.bluetooth
AlertDialog(
onDismissRequest = { showBluetoothDialog = false },
title = { Text(text = "蓝牙详情") },
text = {
Column {
bluetoothInfo.bluetoothAdapter?.let {
Text("适配器名称: ${bluetoothInfo.adapterName ?: "N/A"}")
Text("MAC 地址: ${bluetoothInfo.adapterMacAddress ?: "N/A"}")
Text("已配对设备数量: ${bluetoothInfo.bondedDevices.size}")
bluetoothInfo.bondedDevices.forEach { (name, address) ->
Text(" - ${name ?: "未知设备"} ($address)")
}
} ?: run {
Text("蓝牙适配器不可用")
}
Text("支持低功耗蓝牙: ${bluetoothInfo.isBluetoothLeSupported}")
Text("所需权限: ${bluetoothInfo.requiredPermissions.joinToString()}")
}
},
confirmButton = {
TextButton(onClick = { showBluetoothDialog = false }) {
Text("确认")
}
}
)
}
if (showStorageDialog) {
val storageInfo = AndInfo.instance.storage
AlertDialog(
onDismissRequest = { showStorageDialog = false },
title = { Text(text = "存储详情") },
text = {
LazyColumn {
item { Text("内部存储总空间: ${Formatter.formatFileSize(AndInfo.instance.context, storageInfo.internalStorageTotalSpace)}") }
item { Text("内部存储可用空间: ${Formatter.formatFileSize(AndInfo.instance.context, storageInfo.internalStorageAvailableSpace)}") }
item { Text("内部存储已用空间: ${Formatter.formatFileSize(AndInfo.instance.context, storageInfo.internalStorageUsedSpace)}") }
storageInfo.isInternalStorageEncrypted?.let { item { Text("内部存储已加密: $it") } }
storageInfo.internalStorageEncryptionType?.let { item { Text("内部存储加密类型: $it") } }
item { Spacer(modifier = Modifier.height(8.dp)) }
storageInfo.externalStorageTotalSpace?.let { total ->
item { Text("外部存储总空间: ${Formatter.formatFileSize(AndInfo.instance.context, total)}") }
} ?: item { Text("外部存储总空间: 不可用") }
storageInfo.externalStorageAvailableSpace?.let { available ->
item { Text("外部存储可用空间: ${Formatter.formatFileSize(AndInfo.instance.context, available)}") }
} ?: item { Text("外部存储可用空间: 不可用") }
storageInfo.externalStorageUsedSpace?.let { used ->
item { Text("外部存储已用空间: ${Formatter.formatFileSize(AndInfo.instance.context, used)}") }
} ?: item { Text("外部存储已用空间: 不可用") }
item { Text("外部存储是否模拟: ${storageInfo.isExternalStorageEmulated}") }
item { Text("外部存储是否可移除: ${storageInfo.isExternalStorageRemovable}") }
item { Spacer(modifier = Modifier.height(8.dp)) }
storageInfo.hasUpdatableApex?.let { item { Text("有可更新的 APEX: $it") } }
storageInfo.usesSystemAsRoot?.let { item { Text("使用 System-as-Root: $it") } }
storageInfo.usesAb?.let { item { Text("使用 A/B 更新: $it") } }
storageInfo.abOtaPartitions?.let { item { Text("A/B OTA 分区: ${it.joinToString()}") } }
storageInfo.usesDynamicPartitions?.let { item { Text("使用动态分区: $it") } }
storageInfo.usesRetrofittedDynamicPartitions?.let { item { Text("使用改造的动态分区: $it") } }
storageInfo.usesVirtualAb?.let { item { Text("使用虚拟 A/B: $it") } }
storageInfo.usesRetrofittedVirtualAb?.let { item { Text("使用改造的虚拟 A/B: $it") } }
storageInfo.usesCompressedVirtualAb?.let { item { Text("使用压缩虚拟 A/B: $it") } }
}
},
confirmButton = {
TextButton(onClick = { showStorageDialog = false }) {
Text("确认")
}
}
)
}
} }