// dear imgui: Platform Backend for Android native app
// This needs to be used along with a Renderer Backend (e.g. OpenGL3, Vulkan)

// Implemented features:
//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy AKEYCODE_* values are obsolete since 1.87 and not supported since 1.91.5]
//  [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen/Pen.
//  [X] Platform: On-screen keyboard (soft input) — handled internally via JNI. No application code needed. (#3446)
//  [X] Platform: Unicode character input — handled internally via JNI. No application code needed. (#3446)
//  [X] Platform: Clipboard support (via JNI to Android ClipboardManager). (#7259)
// Missing features or Issues:
//  [ ] Platform: Gamepad support.
//  [ ] Platform: Mouse cursor shape and visibility (ImGuiBackendFlags_HasMouseCursors). Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. FIXME: Check if this is even possible with Android.
// Important:
//  - Consider using SDL or GLFW backend on Android, which will be more full-featured than this.
//  - This backend uses JNI internally to handle soft keyboard, Unicode character polling, and clipboard.
//    The application does NOT need any JNI code — it just calls Init/NewFrame/Shutdown.

// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
// Learn about Dear ImGui:
// - FAQ                  https://dearimgui.com/faq
// - Getting Started      https://dearimgui.com/getting-started
// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
// - Introduction, links and more at the top of imgui.cpp

// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
//  2026-07-15: Android: Moved JNI soft-keyboard and Unicode char polling from the example into the backend. (#3446)
//                Added clipboard support via JNI. (#7259)
//                Added display metrics (DPI, density, refresh rate, orientation) via JNI.
//                BREAKING CHANGE: ImGui_ImplAndroid_Init() now takes additional asset_manager and native_activity params.
//  2022-09-26: Inputs: Renamed ImGuiKey_ModXXX introduced in 1.87 to ImGuiMod_XXX (old names still supported).
//  2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago) with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
//  2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
//  2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
//  2021-03-04: Initial version.

#include "imgui.h"
#ifndef IMGUI_DISABLE
#include "imgui_impl_android.h"
#include <time.h>
#include <string.h>
#include <android/native_window.h>
#include <android/input.h>
#include <android/keycodes.h>
#include <android/log.h>
#include <jni.h>

// Android data
static double                                   g_Time = 0.0;
static ANativeWindow*                           g_Window = nullptr;
static AAssetManager*                           g_AssetManager = nullptr;
static char                                     g_LogTag[] = "ImGuiBackend";

// JNI state (for soft keyboard, Unicode polling, clipboard, display metrics)
static JavaVM*                                  g_JavaVM = nullptr;
static jobject                                  g_NativeActivity = nullptr;  // Global ref
static bool                                     g_HasJni = false;

// Clipboard state
static char*                                    g_ClipboardText = nullptr;

// Display metrics
static ImGui_ImplAndroid_DisplayMetrics         g_DisplayMetrics = {};


// Forward declarations of JNI helpers
static void ImGui_ImplAndroid_JniShowSoftKeyboard();
static void ImGui_ImplAndroid_JniHideSoftKeyboard();
static void ImGui_ImplAndroid_JniPollUnicodeChars();
static void ImGui_ImplAndroid_JniSetClipboardText(const char* text);
static const char* ImGui_ImplAndroid_JniGetClipboardText();

static ImGuiKey ImGui_ImplAndroid_KeyCodeToImGuiKey(int32_t key_code)
{
    switch (key_code)
    {
        case AKEYCODE_TAB:                  return ImGuiKey_Tab;
        case AKEYCODE_DPAD_LEFT:            return ImGuiKey_LeftArrow;
        case AKEYCODE_DPAD_RIGHT:           return ImGuiKey_RightArrow;
        case AKEYCODE_DPAD_UP:              return ImGuiKey_UpArrow;
        case AKEYCODE_DPAD_DOWN:            return ImGuiKey_DownArrow;
        case AKEYCODE_PAGE_UP:              return ImGuiKey_PageUp;
        case AKEYCODE_PAGE_DOWN:            return ImGuiKey_PageDown;
        case AKEYCODE_MOVE_HOME:            return ImGuiKey_Home;
        case AKEYCODE_MOVE_END:             return ImGuiKey_End;
        case AKEYCODE_INSERT:               return ImGuiKey_Insert;
        case AKEYCODE_FORWARD_DEL:          return ImGuiKey_Delete;
        case AKEYCODE_DEL:                  return ImGuiKey_Backspace;
        case AKEYCODE_SPACE:                return ImGuiKey_Space;
        case AKEYCODE_ENTER:                return ImGuiKey_Enter;
        case AKEYCODE_ESCAPE:               return ImGuiKey_Escape;
        case AKEYCODE_APOSTROPHE:           return ImGuiKey_Apostrophe;
        case AKEYCODE_COMMA:                return ImGuiKey_Comma;
        case AKEYCODE_MINUS:                return ImGuiKey_Minus;
        case AKEYCODE_PERIOD:               return ImGuiKey_Period;
        case AKEYCODE_SLASH:                return ImGuiKey_Slash;
        case AKEYCODE_SEMICOLON:            return ImGuiKey_Semicolon;
        case AKEYCODE_EQUALS:               return ImGuiKey_Equal;
        case AKEYCODE_LEFT_BRACKET:         return ImGuiKey_LeftBracket;
        case AKEYCODE_BACKSLASH:            return ImGuiKey_Backslash;
        case AKEYCODE_RIGHT_BRACKET:        return ImGuiKey_RightBracket;
        case AKEYCODE_GRAVE:                return ImGuiKey_GraveAccent;
        case AKEYCODE_CAPS_LOCK:            return ImGuiKey_CapsLock;
        case AKEYCODE_SCROLL_LOCK:          return ImGuiKey_ScrollLock;
        case AKEYCODE_NUM_LOCK:             return ImGuiKey_NumLock;
        case AKEYCODE_SYSRQ:                return ImGuiKey_PrintScreen;
        case AKEYCODE_BREAK:                return ImGuiKey_Pause;
        case AKEYCODE_NUMPAD_0:             return ImGuiKey_Keypad0;
        case AKEYCODE_NUMPAD_1:             return ImGuiKey_Keypad1;
        case AKEYCODE_NUMPAD_2:             return ImGuiKey_Keypad2;
        case AKEYCODE_NUMPAD_3:             return ImGuiKey_Keypad3;
        case AKEYCODE_NUMPAD_4:             return ImGuiKey_Keypad4;
        case AKEYCODE_NUMPAD_5:             return ImGuiKey_Keypad5;
        case AKEYCODE_NUMPAD_6:             return ImGuiKey_Keypad6;
        case AKEYCODE_NUMPAD_7:             return ImGuiKey_Keypad7;
        case AKEYCODE_NUMPAD_8:             return ImGuiKey_Keypad8;
        case AKEYCODE_NUMPAD_9:             return ImGuiKey_Keypad9;
        case AKEYCODE_NUMPAD_DOT:           return ImGuiKey_KeypadDecimal;
        case AKEYCODE_NUMPAD_DIVIDE:        return ImGuiKey_KeypadDivide;
        case AKEYCODE_NUMPAD_MULTIPLY:      return ImGuiKey_KeypadMultiply;
        case AKEYCODE_NUMPAD_SUBTRACT:      return ImGuiKey_KeypadSubtract;
        case AKEYCODE_NUMPAD_ADD:           return ImGuiKey_KeypadAdd;
        case AKEYCODE_NUMPAD_ENTER:         return ImGuiKey_KeypadEnter;
        case AKEYCODE_NUMPAD_EQUALS:        return ImGuiKey_KeypadEqual;
        case AKEYCODE_CTRL_LEFT:            return ImGuiKey_LeftCtrl;
        case AKEYCODE_SHIFT_LEFT:           return ImGuiKey_LeftShift;
        case AKEYCODE_ALT_LEFT:             return ImGuiKey_LeftAlt;
        case AKEYCODE_META_LEFT:            return ImGuiKey_LeftSuper;
        case AKEYCODE_CTRL_RIGHT:           return ImGuiKey_RightCtrl;
        case AKEYCODE_SHIFT_RIGHT:          return ImGuiKey_RightShift;
        case AKEYCODE_ALT_RIGHT:            return ImGuiKey_RightAlt;
        case AKEYCODE_META_RIGHT:           return ImGuiKey_RightSuper;
        case AKEYCODE_MENU:                 return ImGuiKey_Menu;
        case AKEYCODE_0:                    return ImGuiKey_0;
        case AKEYCODE_1:                    return ImGuiKey_1;
        case AKEYCODE_2:                    return ImGuiKey_2;
        case AKEYCODE_3:                    return ImGuiKey_3;
        case AKEYCODE_4:                    return ImGuiKey_4;
        case AKEYCODE_5:                    return ImGuiKey_5;
        case AKEYCODE_6:                    return ImGuiKey_6;
        case AKEYCODE_7:                    return ImGuiKey_7;
        case AKEYCODE_8:                    return ImGuiKey_8;
        case AKEYCODE_9:                    return ImGuiKey_9;
        case AKEYCODE_A:                    return ImGuiKey_A;
        case AKEYCODE_B:                    return ImGuiKey_B;
        case AKEYCODE_C:                    return ImGuiKey_C;
        case AKEYCODE_D:                    return ImGuiKey_D;
        case AKEYCODE_E:                    return ImGuiKey_E;
        case AKEYCODE_F:                    return ImGuiKey_F;
        case AKEYCODE_G:                    return ImGuiKey_G;
        case AKEYCODE_H:                    return ImGuiKey_H;
        case AKEYCODE_I:                    return ImGuiKey_I;
        case AKEYCODE_J:                    return ImGuiKey_J;
        case AKEYCODE_K:                    return ImGuiKey_K;
        case AKEYCODE_L:                    return ImGuiKey_L;
        case AKEYCODE_M:                    return ImGuiKey_M;
        case AKEYCODE_N:                    return ImGuiKey_N;
        case AKEYCODE_O:                    return ImGuiKey_O;
        case AKEYCODE_P:                    return ImGuiKey_P;
        case AKEYCODE_Q:                    return ImGuiKey_Q;
        case AKEYCODE_R:                    return ImGuiKey_R;
        case AKEYCODE_S:                    return ImGuiKey_S;
        case AKEYCODE_T:                    return ImGuiKey_T;
        case AKEYCODE_U:                    return ImGuiKey_U;
        case AKEYCODE_V:                    return ImGuiKey_V;
        case AKEYCODE_W:                    return ImGuiKey_W;
        case AKEYCODE_X:                    return ImGuiKey_X;
        case AKEYCODE_Y:                    return ImGuiKey_Y;
        case AKEYCODE_Z:                    return ImGuiKey_Z;
        case AKEYCODE_F1:                   return ImGuiKey_F1;
        case AKEYCODE_F2:                   return ImGuiKey_F2;
        case AKEYCODE_F3:                   return ImGuiKey_F3;
        case AKEYCODE_F4:                   return ImGuiKey_F4;
        case AKEYCODE_F5:                   return ImGuiKey_F5;
        case AKEYCODE_F6:                   return ImGuiKey_F6;
        case AKEYCODE_F7:                   return ImGuiKey_F7;
        case AKEYCODE_F8:                   return ImGuiKey_F8;
        case AKEYCODE_F9:                   return ImGuiKey_F9;
        case AKEYCODE_F10:                  return ImGuiKey_F10;
        case AKEYCODE_F11:                  return ImGuiKey_F11;
        case AKEYCODE_F12:                  return ImGuiKey_F12;
        default:                            return ImGuiKey_None;
    }
}

int32_t ImGui_ImplAndroid_HandleInputEvent(const AInputEvent* input_event)
{
    ImGuiIO& io = ImGui::GetIO();
    int32_t event_type = AInputEvent_getType(input_event);
    switch (event_type)
    {
    case AINPUT_EVENT_TYPE_KEY:
    {
        int32_t event_key_code = AKeyEvent_getKeyCode(input_event);
        int32_t event_scan_code = AKeyEvent_getScanCode(input_event);
        int32_t event_action = AKeyEvent_getAction(input_event);
        int32_t event_meta_state = AKeyEvent_getMetaState(input_event);

        io.AddKeyEvent(ImGuiMod_Ctrl,  (event_meta_state & AMETA_CTRL_ON)  != 0);
        io.AddKeyEvent(ImGuiMod_Shift, (event_meta_state & AMETA_SHIFT_ON) != 0);
        io.AddKeyEvent(ImGuiMod_Alt,   (event_meta_state & AMETA_ALT_ON)   != 0);
        io.AddKeyEvent(ImGuiMod_Super, (event_meta_state & AMETA_META_ON)  != 0);

        switch (event_action)
        {
        // FIXME: AKEY_EVENT_ACTION_DOWN and AKEY_EVENT_ACTION_UP occur at once as soon as a touch pointer
        // goes up from a key. We use a simple key event queue/ and process one event per key per frame in
        // ImGui_ImplAndroid_NewFrame()...or consider using IO queue, if suitable: https://github.com/ocornut/imgui/issues/2787
        case AKEY_EVENT_ACTION_DOWN:
        case AKEY_EVENT_ACTION_UP:
        {
            ImGuiKey key = ImGui_ImplAndroid_KeyCodeToImGuiKey(event_key_code);
            if (key != ImGuiKey_None)
            {
                io.AddKeyEvent(key, event_action == AKEY_EVENT_ACTION_DOWN);
                io.SetKeyEventNativeData(key, event_key_code, event_scan_code);
            }

            break;
        }
        default:
            break;
        }
        break;
    }
    case AINPUT_EVENT_TYPE_MOTION:
    {
        int32_t event_action = AMotionEvent_getAction(input_event);
        int32_t event_pointer_index = (event_action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
        event_action &= AMOTION_EVENT_ACTION_MASK;

        switch (AMotionEvent_getToolType(input_event, event_pointer_index))
        {
        case AMOTION_EVENT_TOOL_TYPE_MOUSE:
            io.AddMouseSourceEvent(ImGuiMouseSource_Mouse);
            break;
        case AMOTION_EVENT_TOOL_TYPE_STYLUS:
        case AMOTION_EVENT_TOOL_TYPE_ERASER:
            io.AddMouseSourceEvent(ImGuiMouseSource_Pen);
            break;
        case AMOTION_EVENT_TOOL_TYPE_FINGER:
        default:
            io.AddMouseSourceEvent(ImGuiMouseSource_TouchScreen);
            break;
        }

        switch (event_action)
        {
        case AMOTION_EVENT_ACTION_DOWN:
        case AMOTION_EVENT_ACTION_UP:
        {
            // Physical mouse buttons (and probably other physical devices) also invoke the actions AMOTION_EVENT_ACTION_DOWN/_UP,
            // but we have to process them separately to identify the actual button pressed. This is done below via
            // AMOTION_EVENT_ACTION_BUTTON_PRESS/_RELEASE. Here, we only process "FINGER" input (and "UNKNOWN", as a fallback).
            int tool_type = AMotionEvent_getToolType(input_event, event_pointer_index);
            if (tool_type == AMOTION_EVENT_TOOL_TYPE_FINGER || tool_type == AMOTION_EVENT_TOOL_TYPE_UNKNOWN)
            {
                io.AddMousePosEvent(AMotionEvent_getX(input_event, event_pointer_index), AMotionEvent_getY(input_event, event_pointer_index));
                io.AddMouseButtonEvent(0, event_action == AMOTION_EVENT_ACTION_DOWN);
            }
            break;
        }
        case AMOTION_EVENT_ACTION_BUTTON_PRESS:
        case AMOTION_EVENT_ACTION_BUTTON_RELEASE:
        {
            int32_t button_state = AMotionEvent_getButtonState(input_event);
            io.AddMouseButtonEvent(0, (button_state & AMOTION_EVENT_BUTTON_PRIMARY) != 0);
            io.AddMouseButtonEvent(1, (button_state & AMOTION_EVENT_BUTTON_SECONDARY) != 0);
            io.AddMouseButtonEvent(2, (button_state & AMOTION_EVENT_BUTTON_TERTIARY) != 0);
            break;
        }
        case AMOTION_EVENT_ACTION_HOVER_MOVE: // Hovering: Tool moves while NOT pressed (such as a physical mouse)
        case AMOTION_EVENT_ACTION_MOVE:       // Touch pointer moves while DOWN
            io.AddMousePosEvent(AMotionEvent_getX(input_event, event_pointer_index), AMotionEvent_getY(input_event, event_pointer_index));
            break;
        case AMOTION_EVENT_ACTION_SCROLL:
            io.AddMouseWheelEvent(AMotionEvent_getAxisValue(input_event, AMOTION_EVENT_AXIS_HSCROLL, event_pointer_index), AMotionEvent_getAxisValue(input_event, AMOTION_EVENT_AXIS_VSCROLL, event_pointer_index));
            break;
        default:
            break;
        }
    }
        return 1;
    default:
        break;
    }

    return 0;
}

// --- JNI helpers ---
// These functions handle the soft keyboard, Unicode character polling, and clipboard
// entirely within the backend so the application code stays clean.

static JNIEnv* ImGui_ImplAndroid_GetEnv()
{
    if (!g_JavaVM)
        return nullptr;
    JNIEnv* env = nullptr;
    jint ret = g_JavaVM->GetEnv((void**)&env, JNI_VERSION_1_6);
    if (ret == JNI_EDETACHED)
    {
        if (g_JavaVM->AttachCurrentThread(&env, nullptr) != JNI_OK)
            return nullptr;
    }
    else if (ret != JNI_OK)
    {
        return nullptr;
    }
    return env;
}

static void ImGui_ImplAndroid_DetachEnv()
{
    if (g_JavaVM)
        g_JavaVM->DetachCurrentThread();
}

static void ImGui_ImplAndroid_JniShowSoftKeyboard()
{
    if (!g_NativeActivity)
        return;
    JNIEnv* env = ImGui_ImplAndroid_GetEnv();
    if (!env) return;

    jclass cls = env->GetObjectClass(g_NativeActivity);
    if (!cls) { ImGui_ImplAndroid_DetachEnv(); return; }

    // Try the NativeActivity showSoftInput method via InputMethodManager
    jmethodID method = env->GetMethodID(cls, "showSoftInput", "()V");
    if (method)
        env->CallVoidMethod(g_NativeActivity, method);
    env->DeleteLocalRef(cls);
    ImGui_ImplAndroid_DetachEnv();
}

static void ImGui_ImplAndroid_JniHideSoftKeyboard()
{
    if (!g_NativeActivity)
        return;
    JNIEnv* env = ImGui_ImplAndroid_GetEnv();
    if (!env) return;

    jclass cls = env->GetObjectClass(g_NativeActivity);
    if (!cls) { ImGui_ImplAndroid_DetachEnv(); return; }

    jmethodID method = env->GetMethodID(cls, "hideSoftInput", "()V");
    if (method)
        env->CallVoidMethod(g_NativeActivity, method);
    env->DeleteLocalRef(cls);
    ImGui_ImplAndroid_DetachEnv();
}

static void ImGui_ImplAndroid_JniPollUnicodeChars()
{
    if (!g_NativeActivity)
        return;
    JNIEnv* env = ImGui_ImplAndroid_GetEnv();
    if (!env) return;

    jclass cls = env->GetObjectClass(g_NativeActivity);
    if (!cls) { ImGui_ImplAndroid_DetachEnv(); return; }

    jmethodID method = env->GetMethodID(cls, "pollUnicodeChar", "()I");
    if (!method) { env->DeleteLocalRef(cls); ImGui_ImplAndroid_DetachEnv(); return; }

    ImGuiIO& io = ImGui::GetIO();
    jint unicode_char;
    while ((unicode_char = env->CallIntMethod(g_NativeActivity, method)) != 0)
        io.AddInputCharacter(unicode_char);

    env->DeleteLocalRef(cls);
    ImGui_ImplAndroid_DetachEnv();
}

static void ImGui_ImplAndroid_JniSetClipboardText(const char* text)
{
    if (!g_NativeActivity || !text)
        return;
    JNIEnv* env = ImGui_ImplAndroid_GetEnv();
    if (!env) return;

    // Get ClipboardManager and set text
    jclass activity_cls = env->GetObjectClass(g_NativeActivity);
    if (!activity_cls) { ImGui_ImplAndroid_DetachEnv(); return; }

    jmethodID get_service = env->GetMethodID(activity_cls, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
    if (!get_service) { env->DeleteLocalRef(activity_cls); ImGui_ImplAndroid_DetachEnv(); return; }

    jstring service_name = env->NewStringUTF("clipboard");
    jobject clipboard = env->CallObjectMethod(g_NativeActivity, get_service, service_name);
    env->DeleteLocalRef(service_name);

    if (clipboard)
    {
        jclass clipboard_cls = env->GetObjectClass(clipboard);
        jmethodID set_text = env->GetMethodID(clipboard_cls, "setText", "(Ljava/lang/CharSequence;)V");
        if (set_text)
        {
            jstring jtext = env->NewStringUTF(text);
            env->CallVoidMethod(clipboard, set_text, jtext);
            env->DeleteLocalRef(jtext);
        }
        env->DeleteLocalRef(clipboard_cls);
        env->DeleteLocalRef(clipboard);
    }
    env->DeleteLocalRef(activity_cls);
    ImGui_ImplAndroid_DetachEnv();
}

static const char* ImGui_ImplAndroid_JniGetClipboardText()
{
    if (!g_NativeActivity)
        return nullptr;
    JNIEnv* env = ImGui_ImplAndroid_GetEnv();
    if (!env) return nullptr;

    jclass activity_cls = env->GetObjectClass(g_NativeActivity);
    if (!activity_cls) { ImGui_ImplAndroid_DetachEnv(); return nullptr; }

    jmethodID get_service = env->GetMethodID(activity_cls, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
    if (!get_service) { env->DeleteLocalRef(activity_cls); ImGui_ImplAndroid_DetachEnv(); return nullptr; }

    jstring service_name = env->NewStringUTF("clipboard");
    jobject clipboard = env->CallObjectMethod(g_NativeActivity, get_service, service_name);
    env->DeleteLocalRef(service_name);

    if (g_ClipboardText) { IM_FREE(g_ClipboardText); g_ClipboardText = nullptr; }

    if (clipboard)
    {
        jclass clipboard_cls = env->GetObjectClass(clipboard);
        jmethodID get_text = env->GetMethodID(clipboard_cls, "getText", "()Ljava/lang/CharSequence;");
        if (get_text)
        {
            jobject sequence = env->CallObjectMethod(clipboard, get_text);
            if (sequence)
            {
                jstring text = (jstring)sequence;
                const char* chars = env->GetStringUTFChars(text, nullptr);
                if (chars)
                {
                    size_t len = strlen(chars);
                    g_ClipboardText = (char*)IM_ALLOC(len + 1);
                    memcpy(g_ClipboardText, chars, len + 1);
                    env->ReleaseStringUTFChars(text, chars);
                }
                env->DeleteLocalRef(sequence);
            }
        }
        env->DeleteLocalRef(clipboard_cls);
        env->DeleteLocalRef(clipboard);
    }
    env->DeleteLocalRef(activity_cls);
    ImGui_ImplAndroid_DetachEnv();
    return g_ClipboardText;
}

void ImGui_ImplAndroid_ShowSoftKeyboard()
{
    ImGui_ImplAndroid_JniShowSoftKeyboard();
}

void ImGui_ImplAndroid_HideSoftKeyboard()
{
    ImGui_ImplAndroid_JniHideSoftKeyboard();
}

bool ImGui_ImplAndroid_Init(ANativeWindow* window, AAssetManager* asset_manager, jobject native_activity)
{
    IMGUI_CHECKVERSION();

    g_Window = window;
    g_AssetManager = asset_manager;
    g_Time = 0.0;

    // Setup backend capabilities flags
    ImGuiIO& io = ImGui::GetIO();
    io.BackendPlatformName = "imgui_impl_android";

    // Setup JNI for soft keyboard, Unicode polling, clipboard, and display metrics
    if (native_activity)
    {
        JNIEnv* env = ImGui_ImplAndroid_GetEnv();
        if (env)
        {
            g_NativeActivity = env->NewGlobalRef(native_activity);
            g_HasJni = true;
            ImGui_ImplAndroid_DetachEnv();
        }
    }

    // Setup clipboard handlers if JNI is available
    if (g_HasJni)
    {
        io.SetClipboardTextFn = [](void* /*user_data*/, const char* text) { ImGui_ImplAndroid_JniSetClipboardText(text); };
        io.GetClipboardTextFn = [](void* /*user_data*/) -> const char* { return ImGui_ImplAndroid_JniGetClipboardText(); };
    }

    }

    // Query display metrics via JNI (if activity available)
    if (g_HasJni)
    {
        JNIEnv* env = ImGui_ImplAndroid_GetEnv();
        if (env)
        {
            jclass activity_cls = env->GetObjectClass(g_NativeActivity);
            if (activity_cls)
            {
                jmethodID get_metrics = env->GetMethodID(activity_cls, "getWindowManager", "()Landroid/view/WindowManager;");
                if (get_metrics)
                {
                    jobject wm = env->CallObjectMethod(g_NativeActivity, get_metrics);
                    if (wm)
                    {
                        jclass wm_cls = env->GetObjectClass(wm);
                        jmethodID get_default_display = env->GetMethodID(wm_cls, "getDefaultDisplay", "()Landroid/view/Display;");
                        if (get_default_display)
                        {
                            jobject display = env->CallObjectMethod(wm, get_default_display);
                            if (display)
                            {
                                jclass display_cls = env->GetObjectClass(display);

                                // Refresh rate
                                jmethodID get_refresh = env->GetMethodID(display_cls, "getRefreshRate", "()F");
                                if (get_refresh)
                                    g_DisplayMetrics.RefreshRate = env->CallFloatMethod(display, get_refresh);

                                // Orientation (getRotation: 0=portrait, 1=landscape, 2=rev portrait, 3=rev landscape)
                                jmethodID get_rotation = env->GetMethodID(display_cls, "getRotation", "()I");
                                if (get_rotation)
                                    g_DisplayMetrics.Orientation = env->CallIntMethod(display, get_rotation);

                                env->DeleteLocalRef(display_cls);
                                env->DeleteLocalRef(display);
                            }
                        }
                        env->DeleteLocalRef(wm_cls);
                        env->DeleteLocalRef(wm);
                    }
                }

                // Display metrics (DPI, density)
                jmethodID get_resources = env->GetMethodID(activity_cls, "getResources", "()Landroid/content/res/Resources;");
                if (get_resources)
                {
                    jobject res = env->CallObjectMethod(g_NativeActivity, get_resources);
                    if (res)
                    {
                        jclass res_cls = env->GetObjectClass(res);
                        jmethodID get_metrics = env->GetMethodID(res_cls, "getDisplayMetrics", "()Landroid/util/DisplayMetrics;");
                        if (get_metrics)
                        {
                            jobject dm = env->CallObjectMethod(res, get_metrics);
                            if (dm)
                            {
                                jclass dm_cls = env->GetObjectClass(dm);
                                jfieldID density_dpi = env->GetFieldID(dm_cls, "densityDpi", "I");
                                jfieldID density = env->GetFieldID(dm_cls, "density", "F");
                                jfieldID xdpi = env->GetFieldID(dm_cls, "xdpi", "F");
                                jfieldID ydpi = env->GetFieldID(dm_cls, "ydpi", "F");
                                jfieldID w_pixels = env->GetFieldID(dm_cls, "widthPixels", "I");
                                jfieldID h_pixels = env->GetFieldID(dm_cls, "heightPixels", "I");

                                if (density_dpi) g_DisplayMetrics.DensityDpi = env->GetIntField(dm, density_dpi);
                                if (density) g_DisplayMetrics.Density = env->GetFloatField(dm, density);
                                if (xdpi) g_DisplayMetrics.Xdpi = env->GetFloatField(dm, xdpi);
                                if (ydpi) g_DisplayMetrics.Ydpi = env->GetFloatField(dm, ydpi);
                                if (w_pixels) g_DisplayMetrics.WidthPixels = env->GetIntField(dm, w_pixels);
                                if (h_pixels) g_DisplayMetrics.HeightPixels = env->GetIntField(dm, h_pixels);

                                env->DeleteLocalRef(dm_cls);
                                env->DeleteLocalRef(dm);
                            }
                        }
                        env->DeleteLocalRef(res_cls);
                        env->DeleteLocalRef(res);
                    }
                }
                env->DeleteLocalRef(activity_cls);
            }
            ImGui_ImplAndroid_DetachEnv();
        }
    }

    // Fallback display metrics from ANativeWindow if JNI didn't provide them
    if (g_Window)
    {
        int32_t w = ANativeWindow_getWidth(g_Window);
        int32_t h = ANativeWindow_getHeight(g_Window);
        if (g_DisplayMetrics.WidthPixels == 0) g_DisplayMetrics.WidthPixels = w;
        if (g_DisplayMetrics.HeightPixels == 0) g_DisplayMetrics.HeightPixels = h;
        if (g_DisplayMetrics.DensityDpi == 0) g_DisplayMetrics.DensityDpi = 160;  // Default to mdpi
        if (g_DisplayMetrics.Density == 0.0f) g_DisplayMetrics.Density = (float)g_DisplayMetrics.DensityDpi / 160.0f;
        if (g_DisplayMetrics.RefreshRate == 0.0f) g_DisplayMetrics.RefreshRate = 60.0f;
    }

    return true;
}

void ImGui_ImplAndroid_Shutdown()
{