Version 2.0.0

README.md

@@ -18,7 +18,19 @@ Please see [LICENSE](https://github.com/MobileGL-Dev/MobileGlues-plugin/blob/mai
 
 Third party components
 ====
-Please see [MobileGlues-release](https://github.com/MobileGL-Dev/MobileGlues-release).
+For the components used by the renderer itself, please see [MobileGlues-release](https://github.com/MobileGL-Dev/MobileGlues-release).
+
+The plugin application additionally uses:
+
+**Miuix** by **compose-miuix-ui** - [Apache License 2.0](https://github.com/compose-miuix-ui/miuix/blob/main/LICENSE): [github](https://github.com/compose-miuix-ui/miuix)
+
+**Jetpack Compose** by **Android Open Source Project (AOSP)** - [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt): [Android Developers](https://developer.android.com/jetpack/compose)
+
+**AndroidX** by **Android Open Source Project (AOSP)** - [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt): [Android Developers](https://developer.android.com/jetpack/androidx)
+
+**kotlinx.coroutines** by **JetBrains** - [Apache License 2.0](https://github.com/Kotlin/kotlinx.coroutines/blob/master/LICENSE.txt): [github](https://github.com/Kotlin/kotlinx.coroutines)
+
+**Gson** by **Google** - [Apache License 2.0](https://github.com/google/gson/blob/main/LICENSE): [github](https://github.com/google/gson)
 
 Check signature of your release
 ====

app/build.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.compose)
 }
 
 android {
@@ -13,8 +14,8 @@ android {
         applicationId = "com.fcl.plugin.mobileglues"
         minSdk = 26
         targetSdk = 36
-        versionCode = 1350
-        versionName = "1.3.5"
+        versionCode = 2000
+        versionName = "2.0.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -47,8 +48,11 @@ android {
             manifestPlaceholders["minMCVer"] = "1.17"
             manifestPlaceholders["maxMCVer"] = "" //为空则不限制 No restriction if empty
 
+            // MG_COUNT_LAUNCH：只有经启动器起来的这一次才算「一次启动」。
+            // 基准测试、各种工具、以及本插件自己 dlopen 一次去读 GL 信息，都不该计数。
             manifestPlaceholders["boatEnv"] = mutableMapOf<String,String>().apply {
                 put("LIBGL_ES", "3")
+                put("MG_COUNT_LAUNCH", "1")
             }.run {
                 var env = ""
                 forEach { (key, value) ->
@@ -61,6 +65,7 @@ android {
                 put("POJAV_RENDERER", "opengles3")
 				put("POJAVEXEC_EGL", "libmobileglues.so")
 				put("LIBGL_EGL", "libmobileglues.so")
+                put("MG_COUNT_LAUNCH", "1")
             }.run {
                 var env = ""
                 forEach { (key, value) ->
@@ -81,12 +86,15 @@ android {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11
     }
-    kotlinOptions {
-        jvmTarget = "11"
+    kotlin {
+        compilerOptions {
+            jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11)
+        }
     }
     buildFeatures {
         buildConfig = true
-        viewBinding = true
+        aidl = true
+        compose = true
     }
     packaging {
         jniLibs {
@@ -97,8 +105,20 @@ android {
 
 dependencies {
     implementation(libs.gson)
-    implementation(libs.appcompat)
-    implementation(libs.constraintlayout)
-    implementation(libs.google.material)
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.compose.ui)
+    implementation(libs.androidx.compose.ui.graphics)
+    implementation(libs.androidx.compose.ui.tooling.preview)
+    implementation(libs.androidx.compose.material3)
+    implementation(libs.androidx.activity.compose)
+    implementation(libs.androidx.lifecycle.runtime.compose)
+    implementation(libs.androidx.documentfile)
+    implementation(libs.miuix.ui)
+    // 协程和 lifecycleScope 以前是从 appcompat 传递依赖里蹭来的，这里显式声明。
+    implementation(libs.coroutines.android)
+    implementation(libs.lifecycle.runtime.ktx)
     implementation(project(":MobileGlues"))
+
+    testImplementation(libs.junit)
+    testImplementation(libs.coroutines.test)
 }

app/src/main/AndroidManifest.xml

@@ -12,7 +12,24 @@
         android:name="android.permission.WRITE_EXTERNAL_STORAGE"
         android:maxSdkVersion="29" />
 
+    <!--
+      ANGLE 随启动器分发，不在本 App 里。跑分要在与游戏相同的驱动上测，就得先看看
+      装了哪些启动器、它们的 native 库目录里有没有 ANGLE——Android 11 起，没在这里
+      点名的包，PackageManager 一律当作不存在。名单与 AngleProvider 的保持一致。
+    -->
+    <queries>
+        <package android:name="com.tungsten.fcl" />
+        <package android:name="com.tungsten.fcm" />
+        <package android:name="com.tungsten.fcl.ngg" />
+        <package android:name="com.tungsten.fcl.qualcommdr" />
+        <package android:name="com.tungsten.fcl.mgdebug.debug" />
+        <package android:name="com.movtery.zalithlauncher.v2" />
+        <package android:name="com.movtery.zalithlauncher.v2.debug" />
+        <package android:name="org.fcl.enchantnet" />
+    </queries>
+
     <application
+        android:name=".MGApplication"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
@@ -30,6 +47,15 @@
             </intent-filter>
         </activity>
 
+        <!--
+          渲染器查询（跑分、GL 信息）的一次性进程。库的静态构造只在首次载入时读
+          MG_ANGLE_DIR 与配置，而库离不开进程——所以每次查询用一个新进程，查完即弃。
+        -->
+        <service
+            android:name=".MgQueryService"
+            android:exported="false"
+            android:process=":mgquery" />
+
         <meta-data
             android:name="fclPlugin"
             android:value="true" />

app/src/main/aidl/com/fcl/plugin/mobileglues/IMgQuery.aidl

@@ -0,0 +1,19 @@
+package com.fcl.plugin.mobileglues;
+
+/**
+ * 渲染器查询：在一次性的 :mgquery 进程里执行。
+ *
+ * 每个方法都是阻塞的同步调用（runBench 可达一分多钟），binder 会占住调用方的一条线程，
+ * 所以只能从后台线程发起。angleDirectory 传空串表示「不借 ANGLE」——AIDL 的 String
+ * 不好表达 null，而渲染器那边空串与 null 本就同义（MG_ANGLE_DIR 的空值状态）。
+ */
+interface IMgQuery {
+    /**
+     * startSections = 起手场景规模，0 用渲染器默认值；maxSections = 本次不得越过的上限，
+     * 0 表示没有。上一次跑分丢了 GL 上下文之后，调用方带着上限重来一次——崩过的那个规模
+     * 只能由调用方记住，查询进程每次都是新的，它自己不可能知道。
+     */
+    String runBench(String mgDirectory, String angleDirectory, int startSections, int maxSections);
+    int benchProgress();
+    String glInfo(String mgDirectory, String angleDirectory);
+}

app/src/main/cpp/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(mobileglues_info_getter SHARED
 )
 
 find_library(android-lib android)
+find_library(log-lib log)
 
 target_compile_options(mobileglues_info_getter PRIVATE
     -Oz
@@ -34,5 +35,6 @@ target_include_directories(mobileglues_info_getter PRIVATE
 
 target_link_libraries(mobileglues_info_getter
     ${android-lib}
+    ${log-lib}
     dl
 )

app/src/main/cpp/mobileglues_info_getter.cpp

@@ -136,6 +136,17 @@ static std::string create_context_and_query() {
 
     out << "Is MobileGlues (>=1.3.3): " << (g_MGQueryCapability.HasMobileGluesExt ? "Yes\n" : "No\n");
 
+    // Which driver actually answered. The loader is the only honest source: the
+    // renderer string cannot be trusted (a system driver may itself be ANGLE),
+    // and the caller's own "did I pass a directory" is an intention, not a fact.
+    // Old renderers lack the symbol; the line is simply absent then, and the
+    // Kotlin side treats that as "unknown".
+    typedef int (*PFN_mg_angle_in_use)();
+    auto p_angle_in_use = (PFN_mg_angle_in_use) dlsym(mg_handle, "mg_angle_in_use");
+    if (p_angle_in_use) {
+        out << "ANGLE in use: " << (p_angle_in_use() ? "yes" : "no") << "\n";
+    }
+
     const GLubyte* renderer = p_glGetString(GL_RENDERER);
     const GLubyte* version = p_glGetString(GL_VERSION);
     const GLubyte* vendor = p_glGetString(GL_VENDOR);
@@ -203,6 +214,118 @@ Java_com_fcl_plugin_mobileglues_MGInfoGetter_getMobileGluesGLInfo(JNIEnv *env,
     return env->NewStringUTF(res.c_str());
 }
 
+// Runs the MultiDraw micro benchmark that lives inside libmobileglues
+// (gl/multidraw_bench.cpp) and returns its JSON verbatim. Same shape as the GL
+// info query: dlopen the renderer, make a context current through its own EGL
+// layer, call one symbol, tear everything down.
+// Published while the benchmark runs so the UI thread can poll how far along it
+// is. The pointer belongs to a dlopen'd library, so it is only valid between
+// the dlsym below and the dlclose at the end of the run -- hence the lock.
+typedef int (*PFN_mg_multidraw_bench_progress)();
+static std::mutex g_bench_progress_mutex;
+static PFN_mg_multidraw_bench_progress p_bench_progress = nullptr;
+
+static void set_bench_progress_fn(PFN_mg_multidraw_bench_progress fn) {
+    std::lock_guard<std::mutex> lock(g_bench_progress_mutex);
+    p_bench_progress = fn;
+}
+
+static std::string create_context_and_bench(int start_sections, int max_sections) {
+    if (!load_mobile_symbols()) return R"({"error":"failed to load libmobileglues symbols"})";
+
+    typedef const char* (*PFN_mg_multidraw_bench_run)(int, int);
+    auto p_bench = (PFN_mg_multidraw_bench_run) dlsym(mg_handle, "mg_multidraw_bench_run");
+    if (!p_bench) {
+        return R"({"error":"mg_multidraw_bench_run is missing; the renderer is too old"})";
+    }
+    // Optional: an older renderer has the benchmark but not the progress
+    // counter, and the caller falls back to an indeterminate spinner.
+    auto p_progress = (PFN_mg_multidraw_bench_progress) dlsym(mg_handle, "mg_multidraw_bench_progress");
+
+    EGLDisplay display = p_eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    if (display == EGL_NO_DISPLAY) return R"({"error":"eglGetDisplay returned EGL_NO_DISPLAY"})";
+
+    EGLint major = 0, minor = 0;
+    if (!p_eglInitialize(display, &major, &minor)) {
+        return R"({"error":"eglInitialize failed"})";
+    }
+
+    EGLint configAttribs[] = {
+            EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+            EGL_RED_SIZE, 8,
+            EGL_GREEN_SIZE, 8,
+            EGL_BLUE_SIZE, 8,
+            EGL_ALPHA_SIZE, 8,
+            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
+            EGL_NONE
+    };
+    EGLConfig config;
+    EGLint numConfigs = 0;
+    if (!p_eglChooseConfig(display, configAttribs, &config, 1, &numConfigs) || numConfigs <= 0) {
+        p_eglTerminate(display);
+        return R"({"error":"eglChooseConfig failed"})";
+    }
+
+    EGLint pbufAttribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
+    EGLSurface surface = p_eglCreatePbufferSurface(display, config, pbufAttribs);
+    if (surface == EGL_NO_SURFACE) {
+        p_eglTerminate(display);
+        return R"({"error":"eglCreatePbufferSurface failed"})";
+    }
+
+    EGLint ctxAttribs3[] = { EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE };
+    EGLContext context = p_eglCreateContext(display, config, EGL_NO_CONTEXT, ctxAttribs3);
+    if (context == EGL_NO_CONTEXT) {
+        p_eglDestroySurface(display, surface);
+        p_eglTerminate(display);
+        return R"({"error":"eglCreateContext failed"})";
+    }
+
+    if (!p_eglMakeCurrent(display, surface, surface, context)) {
+        p_eglDestroyContext(display, context);
+        p_eglDestroySurface(display, surface);
+        p_eglTerminate(display);
+        return R"({"error":"eglMakeCurrent failed"})";
+    }
+
+    set_bench_progress_fn(p_progress);
+    const char* raw = p_bench(start_sections, max_sections);
+    // Copy before teardown: the string lives inside libmobileglues.
+    std::string res = raw ? raw : R"({"error":"benchmark returned nothing"})";
+    set_bench_progress_fn(nullptr);
+
+    p_eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    p_eglDestroySurface(display, surface);
+    p_eglDestroyContext(display, context);
+    p_eglTerminate(display);
+
+    dlclose(mg_handle);
+    mg_handle = nullptr;
+
+    return res;
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_com_fcl_plugin_mobileglues_MGBench_runMultidrawBench(JNIEnv *env, jobject thiz,
+                                                          jint startSections, jint maxSections) {
+    std::string res = create_context_and_bench(startSections, maxSections);
+    printf("MobileGlues MultiDraw bench: \n%s", res.c_str());
+    __android_log_print(ANDROID_LOG_INFO, "MGBench", "%s", res.c_str());
+    return env->NewStringUTF(res.c_str());
+}
+
+// 0..1000 while a benchmark is running, -1 when none is (or when the renderer
+// predates the progress counter). Called from a different thread than the run.
+extern "C"
+JNIEXPORT jint JNICALL
+Java_com_fcl_plugin_mobileglues_MGBench_benchProgress(JNIEnv *env, jobject thiz) {
+    (void)env;
+    (void)thiz;
+    std::lock_guard<std::mutex> lock(g_bench_progress_mutex);
+    return p_bench_progress ? p_bench_progress() : -1;
+}
+
 JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
     (void)vm;
     (void)reserved;

app/src/main/cpp/mobileglues_info_getter.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <jni.h>
+#include <mutex>
 #include <string>
 #include <vector>
 #include <sstream>