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/com/unity3d/ads/gl/EglCore.java

@@ -0,0 +1,150 @@
+package com.unity3d.ads.gl;
+
+import android.opengl.EGL14;
+import android.opengl.EGLConfig;
+import android.opengl.EGLContext;
+import android.opengl.EGLDisplay;
+import android.opengl.EGLSurface;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nEglCore.kt\nKotlin\n*S Kotlin\n*F\n+ 1 EglCore.kt\ncom/unity3d/ads/gl/EglCore\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,205:1\n1#2:206\n*E\n"})
+/* loaded from: classes4.dex */
+public final class EglCore {
+    public static final Companion Companion = new Companion(null);
+    private static final int EGL_RECORDABLE_ANDROID = 12610;
+    public static final int FLAG_RECORDABLE = 1;
+    public static final int FLAG_TRY_GLES3 = 2;
+    private int glVersion;
+    private EGLConfig mEGLConfig;
+    private EGLContext mEGLContext;
+    private EGLDisplay mEGLDisplay;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public EglCore() {
+        this(null, 0, 3, 0 == true ? 1 : 0);
+    }
+
+    public final int getGlVersion() {
+        return this.glVersion;
+    }
+
+    public final void setGlVersion(int i) {
+        this.glVersion = i;
+    }
+
+    public EglCore(EGLContext eGLContext, int i) {
+        EGLConfig config;
+        EGLDisplay eGLDisplay = EGL14.EGL_NO_DISPLAY;
+        this.mEGLDisplay = eGLDisplay;
+        this.mEGLContext = EGL14.EGL_NO_CONTEXT;
+        this.glVersion = -1;
+        if (eGLDisplay != EGL14.EGL_NO_DISPLAY) {
+            throw new RuntimeException("EGL already set up");
+        }
+        eGLContext = eGLContext == null ? EGL14.EGL_NO_CONTEXT : eGLContext;
+        EGLDisplay eglGetDisplay = EGL14.eglGetDisplay(0);
+        this.mEGLDisplay = eglGetDisplay;
+        if (eglGetDisplay == EGL14.EGL_NO_DISPLAY) {
+            throw new RuntimeException("unable to get EGL14 display");
+        }
+        int[] iArr = new int[2];
+        if (!EGL14.eglInitialize(eglGetDisplay, iArr, 0, iArr, 1)) {
+            this.mEGLDisplay = null;
+            throw new RuntimeException("unable to initialize EGL14");
+        }
+        if ((i & 2) != 0 && (config = getConfig(i, 3)) != null) {
+            EGLContext eglCreateContext = EGL14.eglCreateContext(this.mEGLDisplay, config, eGLContext, new int[]{12440, 3, 12344}, 0);
+            if (EGL14.eglGetError() == 12288) {
+                this.mEGLConfig = config;
+                this.mEGLContext = eglCreateContext;
+                this.glVersion = 3;
+            }
+        }
+        if (this.mEGLContext == EGL14.EGL_NO_CONTEXT) {
+            EGLConfig config2 = getConfig(i, 2);
+            if (config2 == null) {
+                throw new RuntimeException("Unable to find a suitable EGLConfig");
+            }
+            EGLContext eglCreateContext2 = EGL14.eglCreateContext(this.mEGLDisplay, config2, eGLContext, new int[]{12440, 2, 12344}, 0);
+            checkEglError("eglCreateContext");
+            this.mEGLConfig = config2;
+            this.mEGLContext = eglCreateContext2;
+            this.glVersion = 2;
+        }
+        EGL14.eglQueryContext(this.mEGLDisplay, this.mEGLContext, 12440, new int[1], 0);
+    }
+
+    public /* synthetic */ EglCore(EGLContext eGLContext, int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
+        this((i2 & 1) != 0 ? null : eGLContext, (i2 & 2) != 0 ? 0 : i);
+    }
+
+    private final EGLConfig getConfig(int i, int i2) {
+        int[] iArr = {12324, 8, 12323, 8, 12322, 8, 12321, 8, 12352, i2 >= 3 ? 68 : 4, 12344, 0, 12344};
+        if ((i & 1) != 0) {
+            iArr[10] = EGL_RECORDABLE_ANDROID;
+            iArr[11] = 1;
+        }
+        EGLConfig[] eGLConfigArr = new EGLConfig[1];
+        if (EGL14.eglChooseConfig(this.mEGLDisplay, iArr, 0, eGLConfigArr, 0, 1, new int[1], 0)) {
+            return eGLConfigArr[0];
+        }
+        return null;
+    }
+
+    public final void release() {
+        EGLDisplay eGLDisplay = this.mEGLDisplay;
+        if (eGLDisplay != EGL14.EGL_NO_DISPLAY) {
+            EGLSurface eGLSurface = EGL14.EGL_NO_SURFACE;
+            EGL14.eglMakeCurrent(eGLDisplay, eGLSurface, eGLSurface, EGL14.EGL_NO_CONTEXT);
+            EGL14.eglDestroyContext(this.mEGLDisplay, this.mEGLContext);
+            EGL14.eglReleaseThread();
+            EGL14.eglTerminate(this.mEGLDisplay);
+        }
+        this.mEGLDisplay = EGL14.EGL_NO_DISPLAY;
+        this.mEGLContext = EGL14.EGL_NO_CONTEXT;
+        this.mEGLConfig = null;
+    }
+
+    public final void finalize() {
+        if (this.mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
+            release();
+        }
+    }
+
+    public final boolean releaseSurface(EGLSurface eGLSurface) {
+        return EGL14.eglDestroySurface(this.mEGLDisplay, eGLSurface);
+    }
+
+    public final EGLSurface createOffscreenSurface(int i, int i2) {
+        EGLSurface eglCreatePbufferSurface = EGL14.eglCreatePbufferSurface(this.mEGLDisplay, this.mEGLConfig, new int[]{12375, i, 12374, i2, 12344}, 0);
+        checkEglError("eglCreatePbufferSurface");
+        if (eglCreatePbufferSurface != null) {
+            return eglCreatePbufferSurface;
+        }
+        throw new RuntimeException("surface was null");
+    }
+
+    public final void makeCurrent(EGLSurface eGLSurface) {
+        if (!EGL14.eglMakeCurrent(this.mEGLDisplay, eGLSurface, eGLSurface, this.mEGLContext)) {
+            throw new RuntimeException("eglMakeCurrent failed");
+        }
+    }
+
+    private final void checkEglError(String str) {
+        int eglGetError = EGL14.eglGetError();
+        if (eglGetError == 12288) {
+            return;
+        }
+        throw new RuntimeException(str + ": EGL error: 0x" + Integer.toHexString(eglGetError));
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+}

decompiled/sources/com/unity3d/ads/gl/EglSurfaceBase.java

@@ -0,0 +1,43 @@
+package com.unity3d.ads.gl;
+
+import android.opengl.EGL14;
+import android.opengl.EGLSurface;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nEglSurfaceBase.kt\nKotlin\n*S Kotlin\n*F\n+ 1 EglSurfaceBase.kt\ncom/unity3d/ads/gl/EglSurfaceBase\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,42:1\n1#2:43\n*E\n"})
+/* loaded from: classes4.dex */
+public class EglSurfaceBase {
+    private EGLSurface mEGLSurface;
+    private EglCore mEglCore;
+    private int mHeight;
+    private int mWidth;
+
+    public EglSurfaceBase(EglCore eglCore) {
+        Intrinsics.checkNotNullParameter(eglCore, "eglCore");
+        this.mEGLSurface = EGL14.EGL_NO_SURFACE;
+        this.mWidth = -1;
+        this.mHeight = -1;
+        this.mEglCore = eglCore;
+    }
+
+    public final void createOffscreenSurface(int i, int i2) {
+        if (this.mEGLSurface != EGL14.EGL_NO_SURFACE) {
+            throw new IllegalStateException("surface already created".toString());
+        }
+        this.mEGLSurface = this.mEglCore.createOffscreenSurface(i, i2);
+        this.mWidth = i;
+        this.mHeight = i2;
+    }
+
+    public final void releaseEglSurface() {
+        this.mEglCore.releaseSurface(this.mEGLSurface);
+        this.mEGLSurface = EGL14.EGL_NO_SURFACE;
+        this.mHeight = -1;
+        this.mWidth = -1;
+    }
+
+    public final void makeCurrent() {
+        this.mEglCore.makeCurrent(this.mEGLSurface);
+    }
+}

decompiled/sources/com/unity3d/ads/gl/OffscreenSurface.java

@@ -0,0 +1,17 @@
+package com.unity3d.ads.gl;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public final class OffscreenSurface extends EglSurfaceBase {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public OffscreenSurface(EglCore eglCore, int i, int i2) {
+        super(eglCore);
+        Intrinsics.checkNotNullParameter(eglCore, "eglCore");
+        createOffscreenSurface(i, i2);
+    }
+
+    public final void release() {
+        releaseEglSurface();
+    }
+}