Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/csdk/glucentralservices/devicetiers/DeviceTier.java

@@ -0,0 +1,22 @@
+package csdk.glucentralservices.devicetiers;
+
+import java.util.Locale;
+
+/* loaded from: classes4.dex */
+public class DeviceTier {
+    public final boolean fallback;
+    public final int tier;
+
+    public DeviceTier(int i) {
+        this(i, false);
+    }
+
+    public DeviceTier(int i, boolean z) {
+        this.tier = i;
+        this.fallback = z;
+    }
+
+    public String toString() {
+        return String.format(Locale.ENGLISH, "DeviceTier[tier: %d, fallback: %s]", Integer.valueOf(this.tier), Boolean.valueOf(this.fallback));
+    }
+}

decompiled/sources/csdk/glucentralservices/devicetiers/DeviceTiers.java

@@ -0,0 +1,228 @@
+package csdk.glucentralservices.devicetiers;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.text.TextUtils;
+import csdk.glucentralservices.devicetiers.DeviceUtil;
+
+/* loaded from: classes4.dex */
+public class DeviceTiers {
+    public static DeviceTier getDeviceTier(Context context) {
+        Point screenSize = DeviceUtil.getScreenSize(context);
+        return getDeviceTier(DeviceUtil.getCpuCount(), screenSize.x, screenSize.y);
+    }
+
+    public static DeviceTier getDeviceTier(int i, int i2, int i3) {
+        return detectQualitySetting(i, new Point(i2, i3));
+    }
+
+    public static DeviceTier detectQualitySetting(int i, Point point) {
+        DeviceUtil.GlesData glesData = DeviceUtil.getGlesData();
+        if (glesData == null) {
+            return fallback(1);
+        }
+        if (isGpuModel("PowerVR", glesData.gpuVendor, glesData.gpuRenderer)) {
+            return detectPowerVRQualitySetting(glesData.gpuRenderer, i, point, glesData.highestEsVersion);
+        }
+        if (isGpuModel("Adreno", glesData.gpuVendor, glesData.gpuRenderer)) {
+            return detectAdrenoQualitySetting(glesData.gpuRenderer, i, point, glesData.highestEsVersion);
+        }
+        if (isGpuModel("Mali", glesData.gpuVendor, glesData.gpuRenderer)) {
+            return detectMaliQualitySetting(glesData.gpuRenderer, i, point, glesData.highestEsVersion);
+        }
+        if (isGpuModel("NVIDIA Tegra", glesData.gpuVendor, glesData.gpuRenderer) || isGpuModel("ULP GeForce", glesData.gpuVendor, glesData.gpuRenderer)) {
+            return detectNvidiaQualitySetting(glesData.gpuRenderer, i, point, glesData.highestEsVersion);
+        }
+        if (isGpuModel("Vivante", glesData.gpuVendor, glesData.gpuRenderer)) {
+            return detectVivanteQualitySettings(glesData.gpuRenderer, i, point, glesData.highestEsVersion);
+        }
+        if (isGpuModel("VideoCore", glesData.gpuVendor, glesData.gpuRenderer)) {
+            return detectVideoCoreQualitySettings(glesData.gpuRenderer, i, point, glesData.highestEsVersion);
+        }
+        return fallback(1);
+    }
+
+    private static DeviceTier detectPowerVRQualitySetting(String str, int i, Point point, int i2) {
+        if (i == 1) {
+            return tier(0);
+        }
+        if (str.contains("540") || str.contains("544") || str.contains("531")) {
+            return i >= 4 ? maxDim(point) > 1800 ? tier(4) : tier(3) : maxDim(point) > 1024 ? tier(3) : tier(2);
+        }
+        if (str.contains("Rogue Han")) {
+            return estimateTierByCores(i, 4, tier(3));
+        }
+        if (str.contains("Rogue Hood")) {
+            return estimateTierByCores(i, 4, tier(3));
+        }
+        if (str.contains("6250")) {
+            return estimateTierByCores(i, 4, tier(4));
+        }
+        if (str.contains("G6200")) {
+            return estimateTierByCores(i, 4, tier(3), 8, tier(5));
+        }
+        if (str.contains("G6430")) {
+            if (minDim(point) > 1080 && minDim(point) <= 1200) {
+                return estimateTierByCores(i, 4, tier(3));
+            }
+            return estimateTierByCores(i, 4, tier(5));
+        }
+        if (str.contains("GM9446") || str.contains("GXA6850")) {
+            return estimateTierByCores(i, 8, tier(6));
+        }
+        return calculateBestFallback(str, i, point, i2);
+    }
+
+    private static DeviceTier detectAdrenoQualitySetting(String str, int i, Point point, int i2) {
+        if (i == 1) {
+            return tier(1);
+        }
+        if (str.contains("225") || str.contains("220") || str.contains("305")) {
+            return estimateTierByCores(i, 2, tier(2), 4, tier(2));
+        }
+        if (str.contains("320")) {
+            return estimateTierByCores(i, 2, tier(2), 4, tier(4));
+        }
+        if (str.contains("308") || str.contains("330") || str.contains("405") || str.contains("418") || str.contains("420") || str.contains("430") || str.contains("505") || str.contains("510") || str.contains("610")) {
+            return estimateTierByCores(i, 4, tier(5), 6, tier(5), 8, tier(5));
+        }
+        if (str.contains("506") || str.contains("530") || str.contains("616") || str.contains("618") || str.contains("630")) {
+            return estimateTierByCores(i, 4, tier(6), 8, tier(6));
+        }
+        if (str.contains("306")) {
+            return estimateTierByCores(i, 4, tier(3));
+        }
+        if (str.contains("304")) {
+            return estimateTierByCores(i, 4, tier(3));
+        }
+        if (str.contains("203")) {
+            return estimateTierByCores(i, 4, tier(1));
+        }
+        if (str.contains("540")) {
+            return estimateTierByCores(i, 8, tier(6));
+        }
+        if (str.contains("640") || str.contains("642") || str.contains("650") || str.contains("660")) {
+            return estimateTierByCores(i, 8, tier(7));
+        }
+        return calculateBestFallback(str, i, point, i2);
+    }
+
+    private static DeviceTier detectMaliQualitySetting(String str, int i, Point point, int i2) {
+        if (str.contains("400")) {
+            return estimateTierByCores(i, 2, tier(2), 4, tier(4));
+        }
+        if (str.contains("604")) {
+            return estimateTierByCores(i, 2, tier(4));
+        }
+        if (str.contains("628")) {
+            return estimateTierByCores(i, 4, tier(4), 8, tier(5));
+        }
+        if (str.contains("760") || str.contains("860")) {
+            return estimateTierByCores(i, 8, tier(5));
+        }
+        if (str.contains("880")) {
+            return estimateTierByCores(i, 4, tier(5), 8, tier(6));
+        }
+        if (str.contains("624")) {
+            return estimateTierByCores(i, 6, tier(4));
+        }
+        if (str.contains("450")) {
+            return estimateTierByCores(i, 4, tier(3), 8, tier(3));
+        }
+        if (str.contains("720")) {
+            return estimateTierByCores(i, 4, tier(2), 8, tier(4));
+        }
+        if (str.contains("830")) {
+            return estimateTierByCores(i, 8, tier(4));
+        }
+        if (str.contains("G71") || str.contains("G72") || str.contains("G76") || str.contains("G77")) {
+            return estimateTierByCores(i, 8, tier(6));
+        }
+        if (str.contains("G78")) {
+            return estimateTierByCores(i, 8, tier(7));
+        }
+        return calculateBestFallback(str, i, point, i2);
+    }
+
+    private static DeviceTier detectNvidiaQualitySetting(String str, int i, Point point, int i2) {
+        if (!str.contains("K1-64") && !str.contains("X1")) {
+            if (str.contains("K1") || i2 >= 3) {
+                return estimateTierByCores(i, 2, tier(5), 4, tier(6));
+            }
+            if (i >= 2) {
+                return estimateTierByCores(i, 2, maxDim(point) > 1024 ? tier(1) : tier(2), 4, tier(4));
+            }
+            return calculateBestFallback(str, i, point, i2);
+        }
+        return estimateTierByCores(i, 2, tier(6));
+    }
+
+    private static DeviceTier detectVivanteQualitySettings(String str, int i, Point point, int i2) {
+        if (!str.contains("GC1000") && !str.contains("GC2000")) {
+            if (str.contains("GC7000UL")) {
+                return estimateTierByCores(i, 4, tier(2));
+            }
+            return fallback(1);
+        }
+        return estimateTierByCores(i, 2, tier(1), 4, tier(1));
+    }
+
+    private static DeviceTier detectVideoCoreQualitySettings(String str, int i, Point point, int i2) {
+        if (str.contains("IV HW")) {
+            return estimateTierByCores(i, 2, tier(2));
+        }
+        return fallback(1);
+    }
+
+    private static DeviceTier tier(int i) {
+        return new DeviceTier(i);
+    }
+
+    private static DeviceTier calculateBestFallback(String str, int i, Point point, int i2) {
+        if (i >= 4) {
+            return fallback(i > 4 ? i2 + 2 : i2 + 1);
+        }
+        return fallback(i2);
+    }
+
+    private static DeviceTier fallback(int i) {
+        return new DeviceTier(i, true);
+    }
+
+    private static int maxDim(Point point) {
+        return Math.max(point.x, point.y);
+    }
+
+    private static int minDim(Point point) {
+        return Math.min(point.x, point.y);
+    }
+
+    private static boolean isGpuModel(String str, String str2, String str3) {
+        return (!TextUtils.isEmpty(str2) && str2.contains(str)) || (!TextUtils.isEmpty(str3) && str3.contains(str));
+    }
+
+    private static DeviceTier estimateTierByCores(int i, Object... objArr) {
+        DeviceTier deviceTier = null;
+        int i2 = 0;
+        while (true) {
+            if (i2 >= objArr.length) {
+                return fallback(deviceTier != null ? deviceTier.tier : 1);
+            }
+            int intValue = ((Integer) objArr[i2]).intValue();
+            DeviceTier deviceTier2 = (DeviceTier) objArr[i2 + 1];
+            if (i <= intValue) {
+                if (i == intValue) {
+                    return deviceTier2;
+                }
+                if (deviceTier == null) {
+                    return fallback(Math.max(1, deviceTier2.tier - 1));
+                }
+                int i3 = deviceTier.tier;
+                int i4 = deviceTier2.tier;
+                return i3 == i4 ? deviceTier2 : fallback(Math.min(i3, i4));
+            }
+            i2 += 2;
+            deviceTier = deviceTier2;
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/devicetiers/DeviceUtil.java

@@ -0,0 +1,239 @@
+package csdk.glucentralservices.devicetiers;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.view.Display;
+import android.view.WindowManager;
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+
+/* loaded from: classes4.dex */
+public class DeviceUtil {
+    private static GlesData sGlesData;
+    private static boolean sGlesDataEvaluated;
+
+    public static class GlesData {
+        public String gpuRenderer;
+        public String gpuVendor;
+        public int highestEsVersion;
+        public String supportedTextureFormat;
+    }
+
+    public static int getCpuCount() {
+        return Runtime.getRuntime().availableProcessors();
+    }
+
+    public static Point getScreenSize(Context context) {
+        Display defaultDisplay = ((WindowManager) context.getSystemService("window")).getDefaultDisplay();
+        Point point = new Point();
+        defaultDisplay.getRealSize(point);
+        return point;
+    }
+
+    public static GlesData getGlesData() {
+        GlesData glesData;
+        synchronized (DeviceUtil.class) {
+            try {
+                if (!sGlesDataEvaluated) {
+                    try {
+                        sGlesData = doGetGlesData();
+                        sGlesDataEvaluated = true;
+                    } catch (Throwable th) {
+                        sGlesDataEvaluated = true;
+                        throw th;
+                    }
+                }
+                glesData = sGlesData;
+            } catch (Throwable th2) {
+                throw th2;
+            }
+        }
+        return glesData;
+    }
+
+    private static GlesData doGetGlesData() {
+        int i;
+        EGL10 egl10 = (EGL10) EGLContext.getEGL();
+        EGLDisplay eglGetDisplay = egl10.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
+        int[] iArr = new int[1];
+        EGLConfig eGLConfig = null;
+        if (!egl10.eglInitialize(eglGetDisplay, null)) {
+            return null;
+        }
+        try {
+            boolean hasExtension = hasExtension(egl10.eglQueryString(eglGetDisplay, 12373), "EGL_KHR_create_context");
+            if (!egl10.eglGetConfigs(eglGetDisplay, null, 0, iArr)) {
+                egl10.eglTerminate(eglGetDisplay);
+                return null;
+            }
+            int i2 = iArr[0];
+            EGLConfig[] eGLConfigArr = new EGLConfig[i2];
+            if (!egl10.eglGetConfigs(eglGetDisplay, eGLConfigArr, i2, iArr)) {
+                egl10.eglTerminate(eglGetDisplay);
+                return null;
+            }
+            int[] iArr2 = new int[1];
+            int i3 = 0;
+            for (int i4 = 0; i4 < iArr[0]; i4++) {
+                if (egl10.eglGetConfigAttrib(eglGetDisplay, eGLConfigArr[i4], 12352, iArr2)) {
+                    if (hasExtension && (iArr2[0] & 64) == 64) {
+                        i = 3;
+                        if (i3 < 3) {
+                            eGLConfig = eGLConfigArr[i4];
+                            i3 = i;
+                        }
+                    } else {
+                        int i5 = iArr2[0];
+                        if ((i5 & 4) == 4) {
+                            i = 2;
+                            if (i3 < 2) {
+                                eGLConfig = eGLConfigArr[i4];
+                                i3 = i;
+                            }
+                        } else if ((i5 & 1) == 1 && i3 < 1) {
+                            eGLConfig = eGLConfigArr[i4];
+                            i3 = 1;
+                        }
+                    }
+                }
+            }
+            GlesData glesData = new GlesData();
+            glesData.highestEsVersion = i3;
+            addGpuData(egl10, eglGetDisplay, eGLConfig, glesData);
+            egl10.eglTerminate(eglGetDisplay);
+            return glesData;
+        } catch (Throwable th) {
+            egl10.eglTerminate(eglGetDisplay);
+            throw th;
+        }
+    }
+
+    private static void addGpuData(final EGL10 egl10, final EGLDisplay eGLDisplay, final EGLConfig eGLConfig, final GlesData glesData) {
+        Thread thread = new Thread() { // from class: csdk.glucentralservices.devicetiers.DeviceUtil.1
+            /* JADX WARN: Code restructure failed: missing block: B:19:0x006b, code lost:
+            
+                r4.supportedTextureFormat = "ETC2";
+             */
+            @Override // java.lang.Thread, java.lang.Runnable
+            /*
+                Code decompiled incorrectly, please refer to instructions dump.
+                To view partially-correct add '--show-bad-code' argument
+            */
+            public void run() {
+                /*
+                    r7 = this;
+                    javax.microedition.khronos.egl.EGL10 r0 = r1
+                    javax.microedition.khronos.egl.EGLDisplay r1 = r2
+                    javax.microedition.khronos.egl.EGLConfig r2 = r3
+                    javax.microedition.khronos.egl.EGLContext r3 = javax.microedition.khronos.egl.EGL10.EGL_NO_CONTEXT
+                    r4 = 0
+                    javax.microedition.khronos.egl.EGLContext r0 = r0.eglCreateContext(r1, r2, r3, r4)
+                    if (r0 != 0) goto L10
+                    return
+                L10:
+                    r1 = 16
+                    r2 = 12375(0x3057, float:1.7341E-41)
+                    r3 = 12374(0x3056, float:1.734E-41)
+                    r5 = 12344(0x3038, float:1.7298E-41)
+                    int[] r1 = new int[]{r2, r1, r3, r1, r5}     // Catch: java.lang.Throwable -> L5a
+                    javax.microedition.khronos.egl.EGL10 r2 = r1     // Catch: java.lang.Throwable -> L5a
+                    javax.microedition.khronos.egl.EGLDisplay r3 = r2     // Catch: java.lang.Throwable -> L5a
+                    javax.microedition.khronos.egl.EGLConfig r5 = r3     // Catch: java.lang.Throwable -> L5a
+                    javax.microedition.khronos.egl.EGLSurface r4 = r2.eglCreatePbufferSurface(r3, r5, r1)     // Catch: java.lang.Throwable -> L5a
+                    javax.microedition.khronos.egl.EGL10 r1 = r1     // Catch: java.lang.Throwable -> L5a
+                    javax.microedition.khronos.egl.EGLDisplay r2 = r2     // Catch: java.lang.Throwable -> L5a
+                    boolean r1 = r1.eglMakeCurrent(r2, r4, r4, r0)     // Catch: java.lang.Throwable -> L5a
+                    if (r1 == 0) goto L75
+                    csdk.glucentralservices.devicetiers.DeviceUtil$GlesData r1 = r4     // Catch: java.lang.Throwable -> L5a
+                    r2 = 7936(0x1f00, float:1.1121E-41)
+                    java.lang.String r2 = android.opengl.GLES10.glGetString(r2)     // Catch: java.lang.Throwable -> L5a
+                    r1.gpuVendor = r2     // Catch: java.lang.Throwable -> L5a
+                    csdk.glucentralservices.devicetiers.DeviceUtil$GlesData r1 = r4     // Catch: java.lang.Throwable -> L5a
+                    r2 = 7937(0x1f01, float:1.1122E-41)
+                    java.lang.String r2 = android.opengl.GLES10.glGetString(r2)     // Catch: java.lang.Throwable -> L5a
+                    r1.gpuRenderer = r2     // Catch: java.lang.Throwable -> L5a
+                    r1 = 20
+                    int[] r2 = new int[r1]     // Catch: java.lang.Throwable -> L5a
+                    r3 = 34466(0x86a2, float:4.8297E-41)
+                    r5 = 0
+                    android.opengl.GLES10.glGetIntegerv(r3, r2, r5)     // Catch: java.lang.Throwable -> L5a
+                    r3 = r2[r5]     // Catch: java.lang.Throwable -> L5a
+                    r6 = 4194304(0x400000, float:5.877472E-39)
+                    if (r3 >= r6) goto L75
+                    if (r3 <= r1) goto L5c
+                    int[] r2 = new int[r3]     // Catch: java.lang.Throwable -> L5a
+                    goto L5c
+                L5a:
+                    r1 = move-exception
+                    goto L91
+                L5c:
+                    r1 = 34467(0x86a3, float:4.8299E-41)
+                    android.opengl.GLES10.glGetIntegerv(r1, r2, r5)     // Catch: java.lang.Throwable -> L5a
+                L62:
+                    if (r5 >= r3) goto L75
+                    r1 = r2[r5]     // Catch: java.lang.Throwable -> L5a
+                    r6 = 37492(0x9274, float:5.2537E-41)
+                    if (r1 != r6) goto L72
+                    csdk.glucentralservices.devicetiers.DeviceUtil$GlesData r1 = r4     // Catch: java.lang.Throwable -> L5a
+                    java.lang.String r2 = "ETC2"
+                    r1.supportedTextureFormat = r2     // Catch: java.lang.Throwable -> L5a
+                    goto L75
+                L72:
+                    int r5 = r5 + 1
+                    goto L62
+                L75:
+                    javax.microedition.khronos.egl.EGL10 r1 = r1
+                    javax.microedition.khronos.egl.EGLDisplay r2 = r2
+                    javax.microedition.khronos.egl.EGLSurface r3 = javax.microedition.khronos.egl.EGL10.EGL_NO_SURFACE
+                    javax.microedition.khronos.egl.EGLContext r5 = javax.microedition.khronos.egl.EGL10.EGL_NO_CONTEXT
+                    r1.eglMakeCurrent(r2, r3, r3, r5)
+                    if (r4 == 0) goto L89
+                    javax.microedition.khronos.egl.EGL10 r1 = r1
+                    javax.microedition.khronos.egl.EGLDisplay r2 = r2
+                    r1.eglDestroySurface(r2, r4)
+                L89:
+                    javax.microedition.khronos.egl.EGL10 r1 = r1
+                    javax.microedition.khronos.egl.EGLDisplay r2 = r2
+                    r1.eglDestroyContext(r2, r0)
+                    return
+                L91:
+                    javax.microedition.khronos.egl.EGL10 r2 = r1
+                    javax.microedition.khronos.egl.EGLDisplay r3 = r2
+                    javax.microedition.khronos.egl.EGLSurface r5 = javax.microedition.khronos.egl.EGL10.EGL_NO_SURFACE
+                    javax.microedition.khronos.egl.EGLContext r6 = javax.microedition.khronos.egl.EGL10.EGL_NO_CONTEXT
+                    r2.eglMakeCurrent(r3, r5, r5, r6)
+                    if (r4 == 0) goto La5
+                    javax.microedition.khronos.egl.EGL10 r2 = r1
+                    javax.microedition.khronos.egl.EGLDisplay r3 = r2
+                    r2.eglDestroySurface(r3, r4)
+                La5:
+                    javax.microedition.khronos.egl.EGL10 r2 = r1
+                    javax.microedition.khronos.egl.EGLDisplay r3 = r2
+                    r2.eglDestroyContext(r3, r0)
+                    throw r1
+                */
+                throw new UnsupportedOperationException("Method not decompiled: csdk.glucentralservices.devicetiers.DeviceUtil.AnonymousClass1.run():void");
+            }
+        };
+        thread.start();
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static boolean hasExtension(String str, String str2) {
+        int indexOf = str.indexOf(str2);
+        while (indexOf >= 0) {
+            int length = indexOf + str2.length();
+            if (length == str.length() || str.charAt(length) == ' ') {
+                return true;
+            }
+            indexOf = str.indexOf(str2, length);
+        }
+        return false;
+    }
+}