diff --git a/myphoneinfo/andinfo/src/main/AndroidManifest.xml b/myphoneinfo/andinfo/src/main/AndroidManifest.xml
index 09f32ab..c067acc 100644
--- a/myphoneinfo/andinfo/src/main/AndroidManifest.xml
+++ b/myphoneinfo/andinfo/src/main/AndroidManifest.xml
@@ -1,5 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <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>
-</manifest>
\ No newline at end of file
+</manifest>
diff --git a/myphoneinfo/andinfo/src/main/cpp/CMakeLists.txt b/myphoneinfo/andinfo/src/main/cpp/CMakeLists.txt
index e471048..84ecba4 100644
--- a/myphoneinfo/andinfo/src/main/cpp/CMakeLists.txt
+++ b/myphoneinfo/andinfo/src/main/cpp/CMakeLists.txt
@@ -13,6 +13,7 @@ add_library(andinfo SHARED
         egl/EglContext.cpp
         egl/EglSession.cpp
         vulkan/VkSession.cpp
+        vulkan/vkloader.cpp
         vulkan_wrapper/vulkan_wrapper.cpp)
 
 target_link_libraries(andinfo
diff --git a/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp b/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp
index 57df7e1..2dc7528 100644
--- a/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp
+++ b/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp
@@ -11,13 +11,20 @@
 
 VkSession::VkSession(const VkInstanceCreateInfo *pCreateInfo,
                      const VkAllocationCallbacks *pAllocator) {
-    if (!IsVulkanSupported()) {
-        throw std::runtime_error("Vulkan not supported");
-    }
-
-    if (vkCreateInstance(pCreateInfo, pAllocator, &mInstance) != VK_SUCCESS) {
+//    if (!IsVulkanSupported()) {
+//        throw std::runtime_error("Vulkan not supported");
+//    }
+    mLoader = new VulkanLoader();
+    mLoader->openLib();
+    mLoader->loadGlobalFuncs();
+    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() {
diff --git a/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp.bak b/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp.bak
new file mode 100644
index 0000000..a7c368e
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.cpp.bak
@@ -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;
+    }
+}
diff --git a/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h b/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h
index 99d4f29..d963025 100644
--- a/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h
+++ b/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h
@@ -7,7 +7,7 @@
 
 #include <memory>
 #include <vector>
-#include "../vulkan_wrapper/vulkan_wrapper.h"
+#include "./vkloader.h"
 
 class VkSession {
 public:
@@ -28,4 +28,5 @@ private:
     VkSession(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator);
 
     VkInstance mInstance = nullptr;
+    VulkanLoader* mLoader= nullptr;
 };
diff --git a/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h.bak b/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h.bak
new file mode 100644
index 0000000..d963025
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/cpp/vulkan/VkSession.h.bak
@@ -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;
+};
diff --git a/myphoneinfo/andinfo/src/main/cpp/vulkan/vkloader.cpp b/myphoneinfo/andinfo/src/main/cpp/vulkan/vkloader.cpp
new file mode 100644
index 0000000..22d44db
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/cpp/vulkan/vkloader.cpp
@@ -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;
+}
diff --git a/myphoneinfo/andinfo/src/main/cpp/vulkan/vkloader.h b/myphoneinfo/andinfo/src/main/cpp/vulkan/vkloader.h
new file mode 100644
index 0000000..6b5002f
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/cpp/vulkan/vkloader.h
@@ -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;
+};
diff --git a/myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.cpp b/myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.cpp
index eb34b37..649d005 100644
--- a/myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.cpp
+++ b/myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.cpp
@@ -17,195 +17,207 @@ static VulkanWrapperStatus InitVulkan() {
         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
-    vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dlsym(libvulkan, "vkCreateInstance"));
-    vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(dlsym(libvulkan, "vkDestroyInstance"));
-    vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(dlsym(libvulkan, "vkEnumeratePhysicalDevices"));
-    vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(dlsym(libvulkan, "vkGetPhysicalDeviceFeatures"));
-    vkGetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceFormatProperties"));
-    vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceImageFormatProperties"));
-    vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceProperties"));
-    vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceQueueFamilyProperties"));
-    vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceMemoryProperties"));
-    vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(libvulkan, "vkGetInstanceProcAddr"));
-    vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(dlsym(libvulkan, "vkGetDeviceProcAddr"));
-    vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(dlsym(libvulkan, "vkCreateDevice"));
-    vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(dlsym(libvulkan, "vkDestroyDevice"));
-    vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(dlsym(libvulkan, "vkEnumerateInstanceExtensionProperties"));
-    vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(dlsym(libvulkan, "vkEnumerateDeviceExtensionProperties"));
-    vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(dlsym(libvulkan, "vkEnumerateInstanceLayerProperties"));
-    vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(dlsym(libvulkan, "vkEnumerateDeviceLayerProperties"));
-    vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(dlsym(libvulkan, "vkGetDeviceQueue"));
-    vkQueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(dlsym(libvulkan, "vkQueueSubmit"));
-    vkQueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(dlsym(libvulkan, "vkQueueWaitIdle"));
-    vkDeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(dlsym(libvulkan, "vkDeviceWaitIdle"));
-    vkAllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(dlsym(libvulkan, "vkAllocateMemory"));
-    vkFreeMemory = reinterpret_cast<PFN_vkFreeMemory>(dlsym(libvulkan, "vkFreeMemory"));
-    vkMapMemory = reinterpret_cast<PFN_vkMapMemory>(dlsym(libvulkan, "vkMapMemory"));
-    vkUnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(dlsym(libvulkan, "vkUnmapMemory"));
-    vkFlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(dlsym(libvulkan, "vkFlushMappedMemoryRanges"));
-    vkInvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(dlsym(libvulkan, "vkInvalidateMappedMemoryRanges"));
-    vkGetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(dlsym(libvulkan, "vkGetDeviceMemoryCommitment"));
-    vkBindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(dlsym(libvulkan, "vkBindBufferMemory"));
-    vkBindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(dlsym(libvulkan, "vkBindImageMemory"));
-    vkGetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(dlsym(libvulkan, "vkGetBufferMemoryRequirements"));
-    vkGetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(dlsym(libvulkan, "vkGetImageMemoryRequirements"));
-    vkGetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(dlsym(libvulkan, "vkGetImageSparseMemoryRequirements"));
-    vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(dlsym(libvulkan, "vkGetPhysicalDeviceSparseImageFormatProperties"));
-    vkQueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(dlsym(libvulkan, "vkQueueBindSparse"));
-    vkCreateFence = reinterpret_cast<PFN_vkCreateFence>(dlsym(libvulkan, "vkCreateFence"));
-    vkDestroyFence = reinterpret_cast<PFN_vkDestroyFence>(dlsym(libvulkan, "vkDestroyFence"));
-    vkResetFences = reinterpret_cast<PFN_vkResetFences>(dlsym(libvulkan, "vkResetFences"));
-    vkGetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(dlsym(libvulkan, "vkGetFenceStatus"));
-    vkWaitForFences = reinterpret_cast<PFN_vkWaitForFences>(dlsym(libvulkan, "vkWaitForFences"));
-    vkCreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(dlsym(libvulkan, "vkCreateSemaphore"));
-    vkDestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(dlsym(libvulkan, "vkDestroySemaphore"));
-    vkCreateEvent = reinterpret_cast<PFN_vkCreateEvent>(dlsym(libvulkan, "vkCreateEvent"));
-    vkDestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(dlsym(libvulkan, "vkDestroyEvent"));
-    vkGetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(dlsym(libvulkan, "vkGetEventStatus"));
-    vkSetEvent = reinterpret_cast<PFN_vkSetEvent>(dlsym(libvulkan, "vkSetEvent"));
-    vkResetEvent = reinterpret_cast<PFN_vkResetEvent>(dlsym(libvulkan, "vkResetEvent"));
-    vkCreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(dlsym(libvulkan, "vkCreateQueryPool"));
-    vkDestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(dlsym(libvulkan, "vkDestroyQueryPool"));
-    vkGetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(dlsym(libvulkan, "vkGetQueryPoolResults"));
-    vkCreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(dlsym(libvulkan, "vkCreateBuffer"));
-    vkDestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(dlsym(libvulkan, "vkDestroyBuffer"));
-    vkCreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(dlsym(libvulkan, "vkCreateBufferView"));
-    vkDestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(dlsym(libvulkan, "vkDestroyBufferView"));
-    vkCreateImage = reinterpret_cast<PFN_vkCreateImage>(dlsym(libvulkan, "vkCreateImage"));
-    vkDestroyImage = reinterpret_cast<PFN_vkDestroyImage>(dlsym(libvulkan, "vkDestroyImage"));
-    vkGetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(dlsym(libvulkan, "vkGetImageSubresourceLayout"));
-    vkCreateImageView = reinterpret_cast<PFN_vkCreateImageView>(dlsym(libvulkan, "vkCreateImageView"));
-    vkDestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(dlsym(libvulkan, "vkDestroyImageView"));
-    vkCreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(dlsym(libvulkan, "vkCreateShaderModule"));
-    vkDestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(dlsym(libvulkan, "vkDestroyShaderModule"));
-    vkCreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(dlsym(libvulkan, "vkCreatePipelineCache"));
-    vkDestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(dlsym(libvulkan, "vkDestroyPipelineCache"));
-    vkGetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(dlsym(libvulkan, "vkGetPipelineCacheData"));
-    vkMergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(dlsym(libvulkan, "vkMergePipelineCaches"));
-    vkCreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(dlsym(libvulkan, "vkCreateGraphicsPipelines"));
-    vkCreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(dlsym(libvulkan, "vkCreateComputePipelines"));
-    vkDestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(dlsym(libvulkan, "vkDestroyPipeline"));
-    vkCreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(dlsym(libvulkan, "vkCreatePipelineLayout"));
-    vkDestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(dlsym(libvulkan, "vkDestroyPipelineLayout"));
-    vkCreateSampler = reinterpret_cast<PFN_vkCreateSampler>(dlsym(libvulkan, "vkCreateSampler"));
-    vkDestroySampler = reinterpret_cast<PFN_vkDestroySampler>(dlsym(libvulkan, "vkDestroySampler"));
-    vkCreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(dlsym(libvulkan, "vkCreateDescriptorSetLayout"));
-    vkDestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(dlsym(libvulkan, "vkDestroyDescriptorSetLayout"));
-    vkCreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(dlsym(libvulkan, "vkCreateDescriptorPool"));
-    vkDestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(dlsym(libvulkan, "vkDestroyDescriptorPool"));
-    vkResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(dlsym(libvulkan, "vkResetDescriptorPool"));
-    vkAllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(dlsym(libvulkan, "vkAllocateDescriptorSets"));
-    vkFreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(dlsym(libvulkan, "vkFreeDescriptorSets"));
-    vkUpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(dlsym(libvulkan, "vkUpdateDescriptorSets"));
-    vkCreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(dlsym(libvulkan, "vkCreateFramebuffer"));
-    vkDestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(dlsym(libvulkan, "vkDestroyFramebuffer"));
-    vkCreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(dlsym(libvulkan, "vkCreateRenderPass"));
-    vkDestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(dlsym(libvulkan, "vkDestroyRenderPass"));
-    vkGetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(dlsym(libvulkan, "vkGetRenderAreaGranularity"));
-    vkCreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(dlsym(libvulkan, "vkCreateCommandPool"));
-    vkDestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(dlsym(libvulkan, "vkDestroyCommandPool"));
-    vkResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(dlsym(libvulkan, "vkResetCommandPool"));
-    vkAllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(dlsym(libvulkan, "vkAllocateCommandBuffers"));
-    vkFreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(dlsym(libvulkan, "vkFreeCommandBuffers"));
-    vkBeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(dlsym(libvulkan, "vkBeginCommandBuffer"));
-    vkEndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(dlsym(libvulkan, "vkEndCommandBuffer"));
-    vkResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(dlsym(libvulkan, "vkResetCommandBuffer"));
-    vkCmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(dlsym(libvulkan, "vkCmdBindPipeline"));
-    vkCmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(dlsym(libvulkan, "vkCmdSetViewport"));
-    vkCmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(dlsym(libvulkan, "vkCmdSetScissor"));
-    vkCmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(dlsym(libvulkan, "vkCmdSetLineWidth"));
-    vkCmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(dlsym(libvulkan, "vkCmdSetDepthBias"));
-    vkCmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(dlsym(libvulkan, "vkCmdSetBlendConstants"));
-    vkCmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(dlsym(libvulkan, "vkCmdSetDepthBounds"));
-    vkCmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(dlsym(libvulkan, "vkCmdSetStencilCompareMask"));
-    vkCmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(dlsym(libvulkan, "vkCmdSetStencilWriteMask"));
-    vkCmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(dlsym(libvulkan, "vkCmdSetStencilReference"));
-    vkCmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(dlsym(libvulkan, "vkCmdBindDescriptorSets"));
-    vkCmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(dlsym(libvulkan, "vkCmdBindIndexBuffer"));
-    vkCmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(dlsym(libvulkan, "vkCmdBindVertexBuffers"));
-    vkCmdDraw = reinterpret_cast<PFN_vkCmdDraw>(dlsym(libvulkan, "vkCmdDraw"));
-    vkCmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(dlsym(libvulkan, "vkCmdDrawIndexed"));
-    vkCmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(dlsym(libvulkan, "vkCmdDrawIndirect"));
-    vkCmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(dlsym(libvulkan, "vkCmdDrawIndexedIndirect"));
-    vkCmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(dlsym(libvulkan, "vkCmdDispatch"));
-    vkCmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(dlsym(libvulkan, "vkCmdDispatchIndirect"));
-    vkCmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(dlsym(libvulkan, "vkCmdCopyBuffer"));
-    vkCmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(dlsym(libvulkan, "vkCmdCopyImage"));
-    vkCmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(dlsym(libvulkan, "vkCmdBlitImage"));
-    vkCmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(dlsym(libvulkan, "vkCmdCopyBufferToImage"));
-    vkCmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(dlsym(libvulkan, "vkCmdCopyImageToBuffer"));
-    vkCmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(dlsym(libvulkan, "vkCmdUpdateBuffer"));
-    vkCmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(dlsym(libvulkan, "vkCmdFillBuffer"));
-    vkCmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(dlsym(libvulkan, "vkCmdClearColorImage"));
-    vkCmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(dlsym(libvulkan, "vkCmdClearDepthStencilImage"));
-    vkCmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(dlsym(libvulkan, "vkCmdClearAttachments"));
-    vkCmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(dlsym(libvulkan, "vkCmdResolveImage"));
-    vkCmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(dlsym(libvulkan, "vkCmdSetEvent"));
-    vkCmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(dlsym(libvulkan, "vkCmdResetEvent"));
-    vkCmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(dlsym(libvulkan, "vkCmdWaitEvents"));
-    vkCmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(dlsym(libvulkan, "vkCmdPipelineBarrier"));
-    vkCmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(dlsym(libvulkan, "vkCmdBeginQuery"));
-    vkCmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(dlsym(libvulkan, "vkCmdEndQuery"));
-    vkCmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(dlsym(libvulkan, "vkCmdResetQueryPool"));
-    vkCmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(dlsym(libvulkan, "vkCmdWriteTimestamp"));
-    vkCmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(dlsym(libvulkan, "vkCmdCopyQueryPoolResults"));
-    vkCmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(dlsym(libvulkan, "vkCmdPushConstants"));
-    vkCmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(dlsym(libvulkan, "vkCmdBeginRenderPass"));
-    vkCmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(dlsym(libvulkan, "vkCmdNextSubpass"));
-    vkCmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(dlsym(libvulkan, "vkCmdEndRenderPass"));
-    vkCmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(dlsym(libvulkan, "vkCmdExecuteCommands"));
-    vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(dlsym(libvulkan, "vkDestroySurfaceKHR"));
-    vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceSupportKHR"));
-    vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
-    vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
-    vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
-    vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(dlsym(libvulkan, "vkCreateSwapchainKHR"));
-    vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(dlsym(libvulkan, "vkDestroySwapchainKHR"));
-    vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(dlsym(libvulkan, "vkGetSwapchainImagesKHR"));
-    vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(dlsym(libvulkan, "vkAcquireNextImageKHR"));
-    vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(dlsym(libvulkan, "vkQueuePresentKHR"));
-    // vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPropertiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceDisplayPropertiesKHR"));
-    // vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
-    // vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast<PFN_vkGetDisplayPlaneSupportedDisplaysKHR>(dlsym(libvulkan, "vkGetDisplayPlaneSupportedDisplaysKHR"));
-    // vkGetDisplayModePropertiesKHR = reinterpret_cast<PFN_vkGetDisplayModePropertiesKHR>(dlsym(libvulkan, "vkGetDisplayModePropertiesKHR"));
-    // vkCreateDisplayModeKHR = reinterpret_cast<PFN_vkCreateDisplayModeKHR>(dlsym(libvulkan, "vkCreateDisplayModeKHR"));
-    // vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast<PFN_vkGetDisplayPlaneCapabilitiesKHR>(dlsym(libvulkan, "vkGetDisplayPlaneCapabilitiesKHR"));
-    // vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast<PFN_vkCreateDisplayPlaneSurfaceKHR>(dlsym(libvulkan, "vkCreateDisplayPlaneSurfaceKHR"));
-    // vkCreateSharedSwapchainsKHR = reinterpret_cast<PFN_vkCreateSharedSwapchainsKHR>(dlsym(libvulkan, "vkCreateSharedSwapchainsKHR"));
+//    vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(vkGetInstanceProcAddr(nullptr, "vkCreateInstance"));
+//    vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(dlsym(libvulkan, "vkDestroyInstance"));
+//    vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(vkGetInstanceProcAddr(nullptr,  "vkEnumeratePhysicalDevices"));
+//    vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceFeatures"));
+//    vkGetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceFormatProperties"));
+//    vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceImageFormatProperties"));
+//    vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceProperties"));
+//    vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceQueueFamilyProperties"));
+//    vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceMemoryProperties"));
+//    vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(vkGetInstanceProcAddr(nullptr,  "vkGetDeviceProcAddr"));
+//    vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(vkGetInstanceProcAddr(nullptr,  "vkCreateDevice"));
+//    vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(vkGetInstanceProcAddr(nullptr,  "vkDestroyDevice"));
+//    vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(vkGetInstanceProcAddr(nullptr,  "vkEnumerateInstanceExtensionProperties"));
+//    vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(vkGetInstanceProcAddr(nullptr,  "vkEnumerateDeviceExtensionProperties"));
+//    vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(vkGetInstanceProcAddr(nullptr,  "vkEnumerateInstanceLayerProperties"));
+//    vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(vkGetInstanceProcAddr(nullptr,  "vkEnumerateDeviceLayerProperties"));
+//    vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(vkGetInstanceProcAddr(nullptr,  "vkGetDeviceQueue"));
+//    vkQueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(vkGetInstanceProcAddr(nullptr,  "vkQueueSubmit"));
+//    vkQueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(vkGetInstanceProcAddr(nullptr,  "vkQueueWaitIdle"));
+//    vkDeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(vkGetInstanceProcAddr(nullptr,  "vkDeviceWaitIdle"));
+//    vkAllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(vkGetInstanceProcAddr(nullptr,  "vkAllocateMemory"));
+//    vkFreeMemory = reinterpret_cast<PFN_vkFreeMemory>(vkGetInstanceProcAddr(nullptr,  "vkFreeMemory"));
+//    vkMapMemory = reinterpret_cast<PFN_vkMapMemory>(vkGetInstanceProcAddr(nullptr,  "vkMapMemory"));
+//    vkUnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(vkGetInstanceProcAddr(nullptr,  "vkUnmapMemory"));
+//    vkFlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(vkGetInstanceProcAddr(nullptr,  "vkFlushMappedMemoryRanges"));
+//    vkInvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(vkGetInstanceProcAddr(nullptr,  "vkInvalidateMappedMemoryRanges"));
+//    vkGetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(vkGetInstanceProcAddr(nullptr,  "vkGetDeviceMemoryCommitment"));
+//    vkBindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(vkGetInstanceProcAddr(nullptr,  "vkBindBufferMemory"));
+//    vkBindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(vkGetInstanceProcAddr(nullptr,  "vkBindImageMemory"));
+//    vkGetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(vkGetInstanceProcAddr(nullptr,  "vkGetBufferMemoryRequirements"));
+//    vkGetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(vkGetInstanceProcAddr(nullptr,  "vkGetImageMemoryRequirements"));
+//    vkGetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(vkGetInstanceProcAddr(nullptr,  "vkGetImageSparseMemoryRequirements"));
+//    vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceSparseImageFormatProperties"));
+//    vkQueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(vkGetInstanceProcAddr(nullptr,  "vkQueueBindSparse"));
+//    vkCreateFence = reinterpret_cast<PFN_vkCreateFence>(vkGetInstanceProcAddr(nullptr,  "vkCreateFence"));
+//    vkDestroyFence = reinterpret_cast<PFN_vkDestroyFence>(vkGetInstanceProcAddr(nullptr,  "vkDestroyFence"));
+//    vkResetFences = reinterpret_cast<PFN_vkResetFences>(vkGetInstanceProcAddr(nullptr,  "vkResetFences"));
+//    vkGetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(vkGetInstanceProcAddr(nullptr,  "vkGetFenceStatus"));
+//    vkWaitForFences = reinterpret_cast<PFN_vkWaitForFences>(vkGetInstanceProcAddr(nullptr,  "vkWaitForFences"));
+//    vkCreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(vkGetInstanceProcAddr(nullptr,  "vkCreateSemaphore"));
+//    vkDestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(vkGetInstanceProcAddr(nullptr,  "vkDestroySemaphore"));
+//    vkCreateEvent = reinterpret_cast<PFN_vkCreateEvent>(vkGetInstanceProcAddr(nullptr,  "vkCreateEvent"));
+//    vkDestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(vkGetInstanceProcAddr(nullptr,  "vkDestroyEvent"));
+//    vkGetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(vkGetInstanceProcAddr(nullptr,  "vkGetEventStatus"));
+//    vkSetEvent = reinterpret_cast<PFN_vkSetEvent>(vkGetInstanceProcAddr(nullptr,  "vkSetEvent"));
+//    vkResetEvent = reinterpret_cast<PFN_vkResetEvent>(vkGetInstanceProcAddr(nullptr,  "vkResetEvent"));
+//    vkCreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(vkGetInstanceProcAddr(nullptr,  "vkCreateQueryPool"));
+//    vkDestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(vkGetInstanceProcAddr(nullptr,  "vkDestroyQueryPool"));
+//    vkGetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(vkGetInstanceProcAddr(nullptr,  "vkGetQueryPoolResults"));
+//    vkCreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(vkGetInstanceProcAddr(nullptr,  "vkCreateBuffer"));
+//    vkDestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(vkGetInstanceProcAddr(nullptr,  "vkDestroyBuffer"));
+//    vkCreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(vkGetInstanceProcAddr(nullptr,  "vkCreateBufferView"));
+//    vkDestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(vkGetInstanceProcAddr(nullptr,  "vkDestroyBufferView"));
+//    vkCreateImage = reinterpret_cast<PFN_vkCreateImage>(vkGetInstanceProcAddr(nullptr,  "vkCreateImage"));
+//    vkDestroyImage = reinterpret_cast<PFN_vkDestroyImage>(vkGetInstanceProcAddr(nullptr,  "vkDestroyImage"));
+//    vkGetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(vkGetInstanceProcAddr(nullptr,  "vkGetImageSubresourceLayout"));
+//    vkCreateImageView = reinterpret_cast<PFN_vkCreateImageView>(vkGetInstanceProcAddr(nullptr,  "vkCreateImageView"));
+//    vkDestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(vkGetInstanceProcAddr(nullptr,  "vkDestroyImageView"));
+//    vkCreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(vkGetInstanceProcAddr(nullptr,  "vkCreateShaderModule"));
+//    vkDestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(vkGetInstanceProcAddr(nullptr,  "vkDestroyShaderModule"));
+//    vkCreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(vkGetInstanceProcAddr(nullptr,  "vkCreatePipelineCache"));
+//    vkDestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(vkGetInstanceProcAddr(nullptr,  "vkDestroyPipelineCache"));
+//    vkGetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(vkGetInstanceProcAddr(nullptr,  "vkGetPipelineCacheData"));
+//    vkMergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(vkGetInstanceProcAddr(nullptr,  "vkMergePipelineCaches"));
+//    vkCreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(vkGetInstanceProcAddr(nullptr,  "vkCreateGraphicsPipelines"));
+//    vkCreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(vkGetInstanceProcAddr(nullptr,  "vkCreateComputePipelines"));
+//    vkDestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(vkGetInstanceProcAddr(nullptr,  "vkDestroyPipeline"));
+//    vkCreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(vkGetInstanceProcAddr(nullptr,  "vkCreatePipelineLayout"));
+//    vkDestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(vkGetInstanceProcAddr(nullptr,  "vkDestroyPipelineLayout"));
+//    vkCreateSampler = reinterpret_cast<PFN_vkCreateSampler>(vkGetInstanceProcAddr(nullptr,  "vkCreateSampler"));
+//    vkDestroySampler = reinterpret_cast<PFN_vkDestroySampler>(vkGetInstanceProcAddr(nullptr,  "vkDestroySampler"));
+//    vkCreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(vkGetInstanceProcAddr(nullptr,  "vkCreateDescriptorSetLayout"));
+//    vkDestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(vkGetInstanceProcAddr(nullptr,  "vkDestroyDescriptorSetLayout"));
+//    vkCreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(vkGetInstanceProcAddr(nullptr,  "vkCreateDescriptorPool"));
+//    vkDestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(vkGetInstanceProcAddr(nullptr,  "vkDestroyDescriptorPool"));
+//    vkResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(vkGetInstanceProcAddr(nullptr,  "vkResetDescriptorPool"));
+//    vkAllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(vkGetInstanceProcAddr(nullptr,  "vkAllocateDescriptorSets"));
+//    vkFreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(vkGetInstanceProcAddr(nullptr,  "vkFreeDescriptorSets"));
+//    vkUpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(vkGetInstanceProcAddr(nullptr,  "vkUpdateDescriptorSets"));
+//    vkCreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(vkGetInstanceProcAddr(nullptr,  "vkCreateFramebuffer"));
+//    vkDestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(vkGetInstanceProcAddr(nullptr,  "vkDestroyFramebuffer"));
+//    vkCreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(vkGetInstanceProcAddr(nullptr,  "vkCreateRenderPass"));
+//    vkDestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(vkGetInstanceProcAddr(nullptr,  "vkDestroyRenderPass"));
+//    vkGetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(vkGetInstanceProcAddr(nullptr,  "vkGetRenderAreaGranularity"));
+//    vkCreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(vkGetInstanceProcAddr(nullptr,  "vkCreateCommandPool"));
+//    vkDestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(vkGetInstanceProcAddr(nullptr,  "vkDestroyCommandPool"));
+//    vkResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(vkGetInstanceProcAddr(nullptr,  "vkResetCommandPool"));
+//    vkAllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(vkGetInstanceProcAddr(nullptr,  "vkAllocateCommandBuffers"));
+//    vkFreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(vkGetInstanceProcAddr(nullptr,  "vkFreeCommandBuffers"));
+//    vkBeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(vkGetInstanceProcAddr(nullptr,  "vkBeginCommandBuffer"));
+//    vkEndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(vkGetInstanceProcAddr(nullptr,  "vkEndCommandBuffer"));
+//    vkResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(vkGetInstanceProcAddr(nullptr,  "vkResetCommandBuffer"));
+//    vkCmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(vkGetInstanceProcAddr(nullptr,  "vkCmdBindPipeline"));
+//    vkCmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetViewport"));
+//    vkCmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetScissor"));
+//    vkCmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetLineWidth"));
+//    vkCmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetDepthBias"));
+//    vkCmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetBlendConstants"));
+//    vkCmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetDepthBounds"));
+//    vkCmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetStencilCompareMask"));
+//    vkCmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetStencilWriteMask"));
+//    vkCmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetStencilReference"));
+//    vkCmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(vkGetInstanceProcAddr(nullptr,  "vkCmdBindDescriptorSets"));
+//    vkCmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(vkGetInstanceProcAddr(nullptr,  "vkCmdBindIndexBuffer"));
+//    vkCmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(vkGetInstanceProcAddr(nullptr,  "vkCmdBindVertexBuffers"));
+//    vkCmdDraw = reinterpret_cast<PFN_vkCmdDraw>(vkGetInstanceProcAddr(nullptr,  "vkCmdDraw"));
+//    vkCmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(vkGetInstanceProcAddr(nullptr,  "vkCmdDrawIndexed"));
+//    vkCmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(vkGetInstanceProcAddr(nullptr,  "vkCmdDrawIndirect"));
+//    vkCmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(vkGetInstanceProcAddr(nullptr,  "vkCmdDrawIndexedIndirect"));
+//    vkCmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(vkGetInstanceProcAddr(nullptr,  "vkCmdDispatch"));
+//    vkCmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(vkGetInstanceProcAddr(nullptr,  "vkCmdDispatchIndirect"));
+//    vkCmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(vkGetInstanceProcAddr(nullptr,  "vkCmdCopyBuffer"));
+//    vkCmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(vkGetInstanceProcAddr(nullptr,  "vkCmdCopyImage"));
+//    vkCmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(vkGetInstanceProcAddr(nullptr,  "vkCmdBlitImage"));
+//    vkCmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(vkGetInstanceProcAddr(nullptr,  "vkCmdCopyBufferToImage"));
+//    vkCmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(vkGetInstanceProcAddr(nullptr,  "vkCmdCopyImageToBuffer"));
+//    vkCmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(vkGetInstanceProcAddr(nullptr,  "vkCmdUpdateBuffer"));
+//    vkCmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(vkGetInstanceProcAddr(nullptr,  "vkCmdFillBuffer"));
+//    vkCmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(vkGetInstanceProcAddr(nullptr,  "vkCmdClearColorImage"));
+//    vkCmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(vkGetInstanceProcAddr(nullptr,  "vkCmdClearDepthStencilImage"));
+//    vkCmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(vkGetInstanceProcAddr(nullptr,  "vkCmdClearAttachments"));
+//    vkCmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(vkGetInstanceProcAddr(nullptr,  "vkCmdResolveImage"));
+//    vkCmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(vkGetInstanceProcAddr(nullptr,  "vkCmdSetEvent"));
+//    vkCmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(vkGetInstanceProcAddr(nullptr,  "vkCmdResetEvent"));
+//    vkCmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(vkGetInstanceProcAddr(nullptr,  "vkCmdWaitEvents"));
+//    vkCmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(vkGetInstanceProcAddr(nullptr,  "vkCmdPipelineBarrier"));
+//    vkCmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(vkGetInstanceProcAddr(nullptr,  "vkCmdBeginQuery"));
+//    vkCmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(vkGetInstanceProcAddr(nullptr,  "vkCmdEndQuery"));
+//    vkCmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(vkGetInstanceProcAddr(nullptr,  "vkCmdResetQueryPool"));
+//    vkCmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(vkGetInstanceProcAddr(nullptr,  "vkCmdWriteTimestamp"));
+//    vkCmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(vkGetInstanceProcAddr(nullptr,  "vkCmdCopyQueryPoolResults"));
+//    vkCmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(vkGetInstanceProcAddr(nullptr,  "vkCmdPushConstants"));
+//    vkCmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(vkGetInstanceProcAddr(nullptr,  "vkCmdBeginRenderPass"));
+//    vkCmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(vkGetInstanceProcAddr(nullptr,  "vkCmdNextSubpass"));
+//    vkCmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(vkGetInstanceProcAddr(nullptr,  "vkCmdEndRenderPass"));
+//    vkCmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(vkGetInstanceProcAddr(nullptr,  "vkCmdExecuteCommands"));
+//    vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(vkGetInstanceProcAddr(nullptr,  "vkDestroySurfaceKHR"));
+//    vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceSurfaceSupportKHR"));
+//    vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
+//    vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceSurfaceFormatsKHR"));
+//    vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceSurfacePresentModesKHR"));
+//    vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateSwapchainKHR"));
+//    vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(vkGetInstanceProcAddr(nullptr,  "vkDestroySwapchainKHR"));
+//    vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetSwapchainImagesKHR"));
+//    vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(vkGetInstanceProcAddr(nullptr,  "vkAcquireNextImageKHR"));
+//    vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(vkGetInstanceProcAddr(nullptr,  "vkQueuePresentKHR"));
+    // vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPropertiesKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceDisplayPropertiesKHR"));
+    // vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
+    // vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast<PFN_vkGetDisplayPlaneSupportedDisplaysKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetDisplayPlaneSupportedDisplaysKHR"));
+    // vkGetDisplayModePropertiesKHR = reinterpret_cast<PFN_vkGetDisplayModePropertiesKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetDisplayModePropertiesKHR"));
+    // vkCreateDisplayModeKHR = reinterpret_cast<PFN_vkCreateDisplayModeKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateDisplayModeKHR"));
+    // vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast<PFN_vkGetDisplayPlaneCapabilitiesKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetDisplayPlaneCapabilitiesKHR"));
+    // vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast<PFN_vkCreateDisplayPlaneSurfaceKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateDisplayPlaneSurfaceKHR"));
+    // vkCreateSharedSwapchainsKHR = reinterpret_cast<PFN_vkCreateSharedSwapchainsKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateSharedSwapchainsKHR"));
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-    // vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(dlsym(libvulkan, "vkCreateXlibSurfaceKHR"));
-    // vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
+    // vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateXlibSurfaceKHR"));
+    // vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
-    // vkCreateXcbSurfaceKHR = reinterpret_cast<PFN_vkCreateXcbSurfaceKHR>(dlsym(libvulkan, "vkCreateXcbSurfaceKHR"));
-    // vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
+    // vkCreateXcbSurfaceKHR = reinterpret_cast<PFN_vkCreateXcbSurfaceKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateXcbSurfaceKHR"));
+    // vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    // vkCreateWaylandSurfaceKHR = reinterpret_cast<PFN_vkCreateWaylandSurfaceKHR>(dlsym(libvulkan, "vkCreateWaylandSurfaceKHR"));
-    // vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
+    // vkCreateWaylandSurfaceKHR = reinterpret_cast<PFN_vkCreateWaylandSurfaceKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateWaylandSurfaceKHR"));
+    // vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_MIR_KHR
-    // vkCreateMirSurfaceKHR = reinterpret_cast<PFN_vkCreateMirSurfaceKHR>(dlsym(libvulkan, "vkCreateMirSurfaceKHR"));
-    // vkGetPhysicalDeviceMirPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceMirPresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceMirPresentationSupportKHR"));
+    // vkCreateMirSurfaceKHR = reinterpret_cast<PFN_vkCreateMirSurfaceKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateMirSurfaceKHR"));
+    // vkGetPhysicalDeviceMirPresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceMirPresentationSupportKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceMirPresentationSupportKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-    // vkCreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(dlsym(libvulkan, "vkCreateAndroidSurfaceKHR"));
+    // vkCreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateAndroidSurfaceKHR"));
 #endif
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-    // vkCreateWin32SurfaceKHR = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(dlsym(libvulkan, "vkCreateWin32SurfaceKHR"));
-    // vkGetPhysicalDeviceWin32PresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(dlsym(libvulkan, "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
+    // vkCreateWin32SurfaceKHR = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(vkGetInstanceProcAddr(nullptr,  "vkCreateWin32SurfaceKHR"));
+    // vkGetPhysicalDeviceWin32PresentationSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(vkGetInstanceProcAddr(nullptr,  "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
 #endif
 #ifdef USE_DEBUG_EXTENTIONS
-    vkCreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(dlsym(libvulkan, "vkCreateDebugReportCallbackEXT"));
-    vkDestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(dlsym(libvulkan, "vkDestroyDebugReportCallbackEXT"));
-    vkDebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(dlsym(libvulkan, "vkDebugReportMessageEXT"));
+    vkCreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(vkGetInstanceProcAddr(nullptr,  "vkCreateDebugReportCallbackEXT"));
+    vkDestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(vkGetInstanceProcAddr(nullptr,  "vkDestroyDebugReportCallbackEXT"));
+    vkDebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(vkGetInstanceProcAddr(nullptr,  "vkDebugReportMessageEXT"));
 #endif
     return SUPPORTED;
 }
diff --git a/myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.h b/myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.h
index 5b49408..27e715a 100644
--- a/myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.h
+++ b/myphoneinfo/andinfo/src/main/cpp/vulkan_wrapper/vulkan_wrapper.h
@@ -22,166 +22,166 @@ bool IsVulkanSupported();
 extern PFN_vkCreateInstance vkCreateInstance;
 extern PFN_vkDestroyInstance vkDestroyInstance;
 extern PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
-extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
-extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
-extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
+//extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
+//extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
+//extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
 extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
-extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
-extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
+//extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
+//extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
 extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
 extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
-extern PFN_vkCreateDevice vkCreateDevice;
-extern PFN_vkDestroyDevice vkDestroyDevice;
-extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
-extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
-extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
-extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
-extern PFN_vkGetDeviceQueue vkGetDeviceQueue;
-extern PFN_vkQueueSubmit vkQueueSubmit;
-extern PFN_vkQueueWaitIdle vkQueueWaitIdle;
-extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
-extern PFN_vkAllocateMemory vkAllocateMemory;
-extern PFN_vkFreeMemory vkFreeMemory;
-extern PFN_vkMapMemory vkMapMemory;
-extern PFN_vkUnmapMemory vkUnmapMemory;
-extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
-extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
-extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
-extern PFN_vkBindBufferMemory vkBindBufferMemory;
-extern PFN_vkBindImageMemory vkBindImageMemory;
-extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
-extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
-extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
-extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties;
-extern PFN_vkQueueBindSparse vkQueueBindSparse;
-extern PFN_vkCreateFence vkCreateFence;
-extern PFN_vkDestroyFence vkDestroyFence;
-extern PFN_vkResetFences vkResetFences;
-extern PFN_vkGetFenceStatus vkGetFenceStatus;
-extern PFN_vkWaitForFences vkWaitForFences;
-extern PFN_vkCreateSemaphore vkCreateSemaphore;
-extern PFN_vkDestroySemaphore vkDestroySemaphore;
-extern PFN_vkCreateEvent vkCreateEvent;
-extern PFN_vkDestroyEvent vkDestroyEvent;
-extern PFN_vkGetEventStatus vkGetEventStatus;
-extern PFN_vkSetEvent vkSetEvent;
-extern PFN_vkResetEvent vkResetEvent;
-extern PFN_vkCreateQueryPool vkCreateQueryPool;
-extern PFN_vkDestroyQueryPool vkDestroyQueryPool;
-extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
-extern PFN_vkCreateBuffer vkCreateBuffer;
-extern PFN_vkDestroyBuffer vkDestroyBuffer;
-extern PFN_vkCreateBufferView vkCreateBufferView;
-extern PFN_vkDestroyBufferView vkDestroyBufferView;
-extern PFN_vkCreateImage vkCreateImage;
-extern PFN_vkDestroyImage vkDestroyImage;
-extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
-extern PFN_vkCreateImageView vkCreateImageView;
-extern PFN_vkDestroyImageView vkDestroyImageView;
-extern PFN_vkCreateShaderModule vkCreateShaderModule;
-extern PFN_vkDestroyShaderModule vkDestroyShaderModule;
-extern PFN_vkCreatePipelineCache vkCreatePipelineCache;
-extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
-extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
-extern PFN_vkMergePipelineCaches vkMergePipelineCaches;
-extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
-extern PFN_vkCreateComputePipelines vkCreateComputePipelines;
-extern PFN_vkDestroyPipeline vkDestroyPipeline;
-extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
-extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
-extern PFN_vkCreateSampler vkCreateSampler;
-extern PFN_vkDestroySampler vkDestroySampler;
-extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
-extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
-extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
-extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
-extern PFN_vkResetDescriptorPool vkResetDescriptorPool;
-extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
-extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
-extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
-extern PFN_vkCreateFramebuffer vkCreateFramebuffer;
-extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
-extern PFN_vkCreateRenderPass vkCreateRenderPass;
-extern PFN_vkDestroyRenderPass vkDestroyRenderPass;
-extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
-extern PFN_vkCreateCommandPool vkCreateCommandPool;
-extern PFN_vkDestroyCommandPool vkDestroyCommandPool;
-extern PFN_vkResetCommandPool vkResetCommandPool;
-extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
-extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
-extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
-extern PFN_vkEndCommandBuffer vkEndCommandBuffer;
-extern PFN_vkResetCommandBuffer vkResetCommandBuffer;
-extern PFN_vkCmdBindPipeline vkCmdBindPipeline;
-extern PFN_vkCmdSetViewport vkCmdSetViewport;
-extern PFN_vkCmdSetScissor vkCmdSetScissor;
-extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
-extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
-extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
-extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
-extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
-extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
-extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
-extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
-extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
-extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
-extern PFN_vkCmdDraw vkCmdDraw;
-extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
-extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
-extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
-extern PFN_vkCmdDispatch vkCmdDispatch;
-extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
-extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
-extern PFN_vkCmdCopyImage vkCmdCopyImage;
-extern PFN_vkCmdBlitImage vkCmdBlitImage;
-extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
-extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
-extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
-extern PFN_vkCmdFillBuffer vkCmdFillBuffer;
-extern PFN_vkCmdClearColorImage vkCmdClearColorImage;
-extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
-extern PFN_vkCmdClearAttachments vkCmdClearAttachments;
-extern PFN_vkCmdResolveImage vkCmdResolveImage;
-extern PFN_vkCmdSetEvent vkCmdSetEvent;
-extern PFN_vkCmdResetEvent vkCmdResetEvent;
-extern PFN_vkCmdWaitEvents vkCmdWaitEvents;
-extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
-extern PFN_vkCmdBeginQuery vkCmdBeginQuery;
-extern PFN_vkCmdEndQuery vkCmdEndQuery;
-extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
-extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
-extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
-extern PFN_vkCmdPushConstants vkCmdPushConstants;
-extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
-extern PFN_vkCmdNextSubpass vkCmdNextSubpass;
-extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
-extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
-
-// VK_KHR_surface
-extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
-extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
-extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
-extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
-extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
-
-// VK_KHR_swapchain
-extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
-extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
-extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
-extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
-extern PFN_vkQueuePresentKHR vkQueuePresentKHR;
-
-// VK_KHR_display
-extern PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR;
-extern PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
-extern PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR;
-extern PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR;
-extern PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR;
-extern PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR;
-extern PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR;
-
-// VK_KHR_display_swapchain
-extern PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR;
+//extern PFN_vkCreateDevice vkCreateDevice;
+//extern PFN_vkDestroyDevice vkDestroyDevice;
+//extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
+//extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
+//extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
+//extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
+//extern PFN_vkGetDeviceQueue vkGetDeviceQueue;
+//extern PFN_vkQueueSubmit vkQueueSubmit;
+//extern PFN_vkQueueWaitIdle vkQueueWaitIdle;
+//extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
+//extern PFN_vkAllocateMemory vkAllocateMemory;
+//extern PFN_vkFreeMemory vkFreeMemory;
+//extern PFN_vkMapMemory vkMapMemory;
+//extern PFN_vkUnmapMemory vkUnmapMemory;
+//extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
+//extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
+//extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
+//extern PFN_vkBindBufferMemory vkBindBufferMemory;
+//extern PFN_vkBindImageMemory vkBindImageMemory;
+//extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
+//extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+//extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
+//extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties;
+//extern PFN_vkQueueBindSparse vkQueueBindSparse;
+//extern PFN_vkCreateFence vkCreateFence;
+//extern PFN_vkDestroyFence vkDestroyFence;
+//extern PFN_vkResetFences vkResetFences;
+//extern PFN_vkGetFenceStatus vkGetFenceStatus;
+//extern PFN_vkWaitForFences vkWaitForFences;
+//extern PFN_vkCreateSemaphore vkCreateSemaphore;
+//extern PFN_vkDestroySemaphore vkDestroySemaphore;
+//extern PFN_vkCreateEvent vkCreateEvent;
+//extern PFN_vkDestroyEvent vkDestroyEvent;
+//extern PFN_vkGetEventStatus vkGetEventStatus;
+//extern PFN_vkSetEvent vkSetEvent;
+//extern PFN_vkResetEvent vkResetEvent;
+//extern PFN_vkCreateQueryPool vkCreateQueryPool;
+//extern PFN_vkDestroyQueryPool vkDestroyQueryPool;
+//extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
+//extern PFN_vkCreateBuffer vkCreateBuffer;
+//extern PFN_vkDestroyBuffer vkDestroyBuffer;
+//extern PFN_vkCreateBufferView vkCreateBufferView;
+//extern PFN_vkDestroyBufferView vkDestroyBufferView;
+//extern PFN_vkCreateImage vkCreateImage;
+//extern PFN_vkDestroyImage vkDestroyImage;
+//extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
+//extern PFN_vkCreateImageView vkCreateImageView;
+//extern PFN_vkDestroyImageView vkDestroyImageView;
+//extern PFN_vkCreateShaderModule vkCreateShaderModule;
+//extern PFN_vkDestroyShaderModule vkDestroyShaderModule;
+//extern PFN_vkCreatePipelineCache vkCreatePipelineCache;
+//extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
+//extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
+//extern PFN_vkMergePipelineCaches vkMergePipelineCaches;
+//extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
+//extern PFN_vkCreateComputePipelines vkCreateComputePipelines;
+//extern PFN_vkDestroyPipeline vkDestroyPipeline;
+//extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
+//extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
+//extern PFN_vkCreateSampler vkCreateSampler;
+//extern PFN_vkDestroySampler vkDestroySampler;
+//extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
+//extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
+//extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
+//extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
+//extern PFN_vkResetDescriptorPool vkResetDescriptorPool;
+//extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
+//extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
+//extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
+//extern PFN_vkCreateFramebuffer vkCreateFramebuffer;
+//extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
+//extern PFN_vkCreateRenderPass vkCreateRenderPass;
+//extern PFN_vkDestroyRenderPass vkDestroyRenderPass;
+//extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
+//extern PFN_vkCreateCommandPool vkCreateCommandPool;
+//extern PFN_vkDestroyCommandPool vkDestroyCommandPool;
+//extern PFN_vkResetCommandPool vkResetCommandPool;
+//extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
+//extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
+//extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
+//extern PFN_vkEndCommandBuffer vkEndCommandBuffer;
+//extern PFN_vkResetCommandBuffer vkResetCommandBuffer;
+//extern PFN_vkCmdBindPipeline vkCmdBindPipeline;
+//extern PFN_vkCmdSetViewport vkCmdSetViewport;
+//extern PFN_vkCmdSetScissor vkCmdSetScissor;
+//extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
+//extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
+//extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
+//extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
+//extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
+//extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
+//extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
+//extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
+//extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
+//extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
+//extern PFN_vkCmdDraw vkCmdDraw;
+//extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
+//extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
+//extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
+//extern PFN_vkCmdDispatch vkCmdDispatch;
+//extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
+//extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
+//extern PFN_vkCmdCopyImage vkCmdCopyImage;
+//extern PFN_vkCmdBlitImage vkCmdBlitImage;
+//extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
+//extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
+//extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
+//extern PFN_vkCmdFillBuffer vkCmdFillBuffer;
+//extern PFN_vkCmdClearColorImage vkCmdClearColorImage;
+//extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
+//extern PFN_vkCmdClearAttachments vkCmdClearAttachments;
+//extern PFN_vkCmdResolveImage vkCmdResolveImage;
+//extern PFN_vkCmdSetEvent vkCmdSetEvent;
+//extern PFN_vkCmdResetEvent vkCmdResetEvent;
+//extern PFN_vkCmdWaitEvents vkCmdWaitEvents;
+//extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
+//extern PFN_vkCmdBeginQuery vkCmdBeginQuery;
+//extern PFN_vkCmdEndQuery vkCmdEndQuery;
+//extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
+//extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
+//extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
+//extern PFN_vkCmdPushConstants vkCmdPushConstants;
+//extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
+//extern PFN_vkCmdNextSubpass vkCmdNextSubpass;
+//extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
+//extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
+//
+//// VK_KHR_surface
+//extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
+//extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
+//extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+//extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
+//extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
+//
+//// VK_KHR_swapchain
+//extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
+//extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
+//extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
+//extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
+//extern PFN_vkQueuePresentKHR vkQueuePresentKHR;
+//
+//// VK_KHR_display
+//extern PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR;
+//extern PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+//extern PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR;
+//extern PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR;
+//extern PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR;
+//extern PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR;
+//extern PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR;
+//
+//// VK_KHR_display_swapchain
+//extern PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR;
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
 // VK_KHR_xlib_surface
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/AndInfo.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/AndInfo.kt
index 6ed81f2..4629b39 100644
--- a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/AndInfo.kt
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/AndInfo.kt
@@ -8,6 +8,9 @@ import com.xyzshell.andinfo.libs.SensorInfo
 import com.xyzshell.andinfo.libs.BuildInfo
 import com.xyzshell.andinfo.libs.GpuInfo
 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) {
 
@@ -34,6 +37,9 @@ class AndInfo private constructor(private val applicationContext: Context) {
     private val _build: BuildInfo
     private val _gpu: GpuInfo
     private val _input: InputInfo
+    private val _camera: CameraInfo
+    private val _bluetooth: BluetoothInfo
+    private val _storage: StorageInfo
 
     init {
         _cpu = CpuInfo()
@@ -43,6 +49,9 @@ class AndInfo private constructor(private val applicationContext: Context) {
         _build = BuildInfo(applicationContext)
         _gpu = GpuInfo(applicationContext)
         _input = InputInfo(applicationContext)
+        _camera = CameraInfo(applicationContext)
+        _bluetooth = BluetoothInfo(applicationContext)
+        _storage = StorageInfo(applicationContext)
     }
 
     val cpu get() = _cpu
@@ -52,6 +61,9 @@ class AndInfo private constructor(private val applicationContext: Context) {
     val build get() = _build
     val gpu get() = _gpu
     val input get() = _input
+    val camera get() = _camera
+    val bluetooth get() = _bluetooth
+    val storage get() = _storage
     val context get() = applicationContext
 
 
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/BluetoothInfo.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/BluetoothInfo.kt
new file mode 100644
index 0000000..fba915e
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/BluetoothInfo.kt
@@ -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()
+}
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/CameraInfo.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/CameraInfo.kt
new file mode 100644
index 0000000..ad59989
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/CameraInfo.kt
@@ -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()
+    }
+}
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/StorageInfo.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/StorageInfo.kt
new file mode 100644
index 0000000..844e5a3
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/StorageInfo.kt
@@ -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")
+}
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/camera/models/CameraModels.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/camera/models/CameraModels.kt
new file mode 100644
index 0000000..28d2731
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/camera/models/CameraModels.kt
@@ -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
+}
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDevice.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDevice.kt
index fcaf8d7..9b1cec5 100644
--- a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDevice.kt
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDevice.kt
@@ -2,10 +2,10 @@ package com.xyzshell.andinfo.libs.gpu.models
 
 data class VkPhysicalDevice(
     val apiVersion: VkVersion,
-    val driverVersion: Int,
-    val vendorId: Int,
+    val driverVersion: Long,
+    val vendorId: Long,
     val registeredVendorId: VkVendorId?,
-    val deviceId: Int,
+    val deviceId: Long,
     val deviceType: VkPhysicalDeviceType,
     val deviceName: String,
 )
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDeviceType.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDeviceType.kt
index 73b9b0a..e8fe3a1 100644
--- a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDeviceType.kt
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkPhysicalDeviceType.kt
@@ -1,6 +1,6 @@
 package com.xyzshell.andinfo.libs.gpu.models
 
-enum class VkPhysicalDeviceType(val value: Int) {
+enum class VkPhysicalDeviceType(val value: Long) {
     OTHER(0),
     INTEGRATED_GPU(1),
     DISCRETE_GPU(2),
@@ -9,6 +9,6 @@ enum class VkPhysicalDeviceType(val value: Int) {
     ;
 
     companion object {
-        fun fromValue(value: Int) = values().firstOrNull { it.value == value }
+        fun fromValue(value: Long) = values().firstOrNull { it.value == value }
     }
 }
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkVendorId.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkVendorId.kt
index 1ca96d6..4a17500 100644
--- a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkVendorId.kt
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/models/VkVendorId.kt
@@ -1,6 +1,6 @@
 package com.xyzshell.andinfo.libs.gpu.models
 
-enum class VkVendorId(val id: Int) {
+enum class VkVendorId(val id: Long) {
     KHRONOS(0x10001),
     VIV(0x10002),
     VSI(0x10003),
@@ -12,6 +12,6 @@ enum class VkVendorId(val id: Int) {
     ;
 
     companion object {
-        fun fromId(id: Int) = values().firstOrNull { it.id == id }
+        fun fromId(id: Long) = values().firstOrNull { it.id == id }
     }
 }
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/utils/VkUtils.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/utils/VkUtils.kt
index d73115f..0b8cc96 100644
--- a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/utils/VkUtils.kt
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/gpu/utils/VkUtils.kt
@@ -14,14 +14,14 @@ object VkUtils {
         fun addDevice(
             apiVersion: Long,
             driverVersion: Long,
-            vendorId: Int,
-            deviceId: Int,
-            deviceType: Int,
+            vendorId: Long,
+            deviceId: Long,
+            deviceType: Long,
             deviceName: String,
         ) = add(
             VkPhysicalDevice(
                 apiVersion = VkVersion(apiVersion.toInt()),
-                driverVersion = driverVersion.toInt(),
+                driverVersion = driverVersion,
                 vendorId = vendorId,
                 registeredVendorId = com.xyzshell.andinfo.libs.gpu.models.VkVendorId.fromId(vendorId),
                 deviceId = deviceId,
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/storage/models/EncryptionType.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/storage/models/EncryptionType.kt
new file mode 100644
index 0000000..9328104
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/storage/models/EncryptionType.kt
@@ -0,0 +1,7 @@
+package com.xyzshell.andinfo.libs.storage.models
+
+enum class EncryptionType {
+    NONE,
+    FDE,
+    FBE
+}
diff --git a/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/utils/SystemProperties.kt b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/utils/SystemProperties.kt
new file mode 100644
index 0000000..d2e2a97
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/utils/SystemProperties.kt
@@ -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)
+    }
+}
diff --git a/myphoneinfo/andinfo/src/main/res/values/strings.xml b/myphoneinfo/andinfo/src/main/res/values/strings.xml
new file mode 100644
index 0000000..d92a54d
--- /dev/null
+++ b/myphoneinfo/andinfo/src/main/res/values/strings.xml
@@ -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>
diff --git a/myphoneinfo/src/main/java/com/xyzshell/myphoneinfo/MainActivity.kt b/myphoneinfo/src/main/java/com/xyzshell/myphoneinfo/MainActivity.kt
index 69b87d6..e61db4b 100644
--- a/myphoneinfo/src/main/java/com/xyzshell/myphoneinfo/MainActivity.kt
+++ b/myphoneinfo/src/main/java/com/xyzshell/myphoneinfo/MainActivity.kt
@@ -1,69 +1,50 @@
 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.text.format.Formatter
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 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.Column
-import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+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.Button
 import androidx.compose.material3.Card
+import androidx.compose.material3.ListItem
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 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.unit.dp
-import com.xyzshell.myphoneinfo.ui.theme.MyAndriodInfoTheme
 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.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.InputDeviceInfo
-import androidx.compose.foundation.clickable
+import com.xyzshell.andinfo.libs.SensorInfo
+import com.xyzshell.myphoneinfo.ui.theme.MyAndriodInfoTheme
+
 
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -73,15 +54,27 @@ class MainActivity : ComponentActivity() {
             MyAndriodInfoTheme {
                 Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                     MainView(
-                        name = "DevCheck Clone",
+                        name = "DevCheck",
                         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
@@ -95,18 +88,25 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
     var showGpuDialog by remember { mutableStateOf(false) }
     var showInputDevicesDialog by remember { mutableStateOf(false) }
     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()){
             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.cores.size}")
             Button(onClick = { showCpuDialog = true }) { Text("CPU 详情") }
         }
         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()
             Text("设备型号：${AndInfo.instance.device.model}")
             Text("制造商：${AndInfo.instance.device.manufacturer}")
@@ -115,7 +115,9 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
             Button(onClick = { showDeviceDialog = true }) { Text("设备详情") }
         }
         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()
             if (defaultDisplayInfo != null) {
                 Text("显示器名称：${defaultDisplayInfo.name}")
@@ -127,28 +129,36 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
             }
         }
         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()
             Text("传感器数量：${allSensors.size}")
             Text("支持动态传感器发现：${AndInfo.instance.sensor.isDynamicSensorDiscoverySupported()}")
             Button(onClick = { showSensorsDialog = true }) { Text("传感器列表") }
         }
         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.type}")
             Text("Android 版本：${AndInfo.instance.build.versionRelease} (SDK ${AndInfo.instance.build.versionSdkInt})")
             Button(onClick = { showBuildDialog = true }) { Text("构建详情") }
         }
         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()
             Text("Vulkan 设备数量：${gpuInfo.vkPhysicalDevices?.size ?: 0}")
             Text("EGL 信息可用：${gpuInfo.eglInformation != null}")
             Button(onClick = { showGpuDialog = true }) { Text("GPU 详情") }
         }
         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()
             Text("输入设备数量：${inputDevices.size}")
             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("输入设备列表") }
         }
+        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) {
@@ -273,7 +313,8 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
                             headlineContent = { Text(sensor.name) },
                             supportingContent = { Text(sensor.stringType) },
                             trailingContent = { Text(sensor.vendor) },
-                            modifier = Modifier.fillMaxWidth()
+                            modifier = Modifier
+                                .fillMaxWidth()
                                 .clickable {
                                     selectedSensor = sensor
                                     showSensorsDialog = false
@@ -462,7 +503,8 @@ fun MainView(name: String, modifier: Modifier = Modifier) {
                         ListItem(
                             headlineContent = { Text(inputDevice.name) },
                             supportingContent = { Text("ID: ${inputDevice.id}, 供应商: ${inputDevice.vendorId}, 产品: ${inputDevice.productId}") },
-                            modifier = Modifier.fillMaxWidth()
+                            modifier = Modifier
+                                .fillMaxWidth()
                                 .clickable {
                                     selectedInputDevice = inputDevice
                                     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("确认")
+                }
+            }
+        )
+    }
 }