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/R.java

@@ -0,0 +1,7 @@
+package csdk.glucentralservices;
+
+/* loaded from: classes4.dex */
+public final class R {
+    private R() {
+    }
+}

decompiled/sources/csdk/glucentralservices/consent/ConsentUI.java

@@ -0,0 +1,430 @@
+package csdk.glucentralservices.consent;
+
+import android.R;
+import android.app.Activity;
+import android.app.Application;
+import android.app.Dialog;
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Base64;
+import android.view.WindowManager;
+import android.webkit.WebResourceError;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import com.facebook.internal.NativeProtocol;
+import com.google.firebase.perf.network.FirebasePerfUrlConnection;
+import csdk.glucentralservices.util.Common;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicReference;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class ConsentUI implements Application.ActivityLifecycleCallbacks {
+    private final Activity mActivity;
+    private JSONObject mConfig;
+    private Dialog mDialog;
+    private AtomicReference<IConsentListener> mListener;
+    private final WebView mWebView;
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle bundle) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(@NonNull Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle bundle) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStarted(@NonNull Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(@NonNull Activity activity) {
+    }
+
+    public ConsentUI(Activity activity) {
+        this.mActivity = activity;
+        activity.getApplication().registerActivityLifecycleCallbacks(this);
+        this.mDialog = new Dialog(activity, R.style.Theme.Translucent.NoTitleBar);
+        this.mListener = new AtomicReference<>(NullConsentListener.INSTANCE);
+        WebView webView = new WebView(activity);
+        this.mWebView = webView;
+        webView.setBackgroundColor(0);
+        this.mDialog.setContentView(webView);
+        this.mDialog.setCancelable(false);
+        webView.getSettings().setJavaScriptEnabled(true);
+        webView.setWebViewClient(new WebViewClient() { // from class: csdk.glucentralservices.consent.ConsentUI.1
+            boolean isInternalRedirect;
+
+            @Override // android.webkit.WebViewClient
+            public void onLoadResource(WebView webView2, String str) {
+                handleUrl(str);
+            }
+
+            @Override // android.webkit.WebViewClient
+            @RequiresApi(api = 24)
+            public boolean shouldOverrideUrlLoading(WebView webView2, WebResourceRequest webResourceRequest) {
+                String uri = webResourceRequest.getUrl().toString();
+                if (!isConsentFormUrl(uri)) {
+                    return false;
+                }
+                handleUrl(uri);
+                return true;
+            }
+
+            @Override // android.webkit.WebViewClient
+            public boolean shouldOverrideUrlLoading(WebView webView2, String str) {
+                if (!isConsentFormUrl(str)) {
+                    return false;
+                }
+                handleUrl(str);
+                return true;
+            }
+
+            @Override // android.webkit.WebViewClient
+            public void onPageFinished(WebView webView2, String str) {
+                if (!this.isInternalRedirect) {
+                    ConsentUI.this.updateDialogContent(webView2);
+                }
+                super.onPageFinished(webView2, str);
+            }
+
+            @Override // android.webkit.WebViewClient
+            @RequiresApi(api = 23)
+            public void onReceivedError(WebView webView2, WebResourceRequest webResourceRequest, WebResourceError webResourceError) {
+                onReceivedError(webView2, webResourceError.getErrorCode(), webResourceError.getDescription().toString(), webResourceRequest.getUrl().toString());
+            }
+
+            @Override // android.webkit.WebViewClient
+            public void onReceivedError(WebView webView2, int i, String str, String str2) {
+                if (isConsentFormUrl(str2)) {
+                    return;
+                }
+                System.out.println("WebViewClient::onReceivedError: " + str2);
+                if (str2.startsWith("http") || str2.startsWith("chrome-extension")) {
+                    return;
+                }
+                ConsentUI.this.onConsentStatusEventReceived(null, new Exception(str));
+            }
+
+            private boolean isConsentFormUrl(String str) {
+                return !TextUtils.isEmpty(str) && str.startsWith("consent://");
+            }
+
+            /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+            /* JADX WARN: Code restructure failed: missing block: B:25:0x004a, code lost:
+            
+                if (r1.equals(androidx.core.app.NotificationCompat.CATEGORY_EVENT) == false) goto L7;
+             */
+            /*
+                Code decompiled incorrectly, please refer to instructions dump.
+                To view partially-correct add '--show-bad-code' argument
+            */
+            private void handleUrl(java.lang.String r7) {
+                /*
+                    r6 = this;
+                    boolean r0 = r6.isConsentFormUrl(r7)
+                    if (r0 != 0) goto L7
+                    return
+                L7:
+                    r0 = 1
+                    r6.isInternalRedirect = r0
+                    android.net.Uri r7 = android.net.Uri.parse(r7)
+                    java.lang.String r1 = "action"
+                    java.lang.String r1 = r7.getQueryParameter(r1)
+                    java.lang.String r2 = "status"
+                    java.lang.String r2 = r7.getQueryParameter(r2)
+                    java.lang.String r3 = "url"
+                    java.lang.String r7 = r7.getQueryParameter(r3)
+                    r1.hashCode()
+                    int r3 = r1.hashCode()
+                    r4 = 0
+                    r5 = -1
+                    switch(r3) {
+                        case -1370505102: goto L4d;
+                        case 96891546: goto L44;
+                        case 150940456: goto L39;
+                        case 1671672458: goto L2e;
+                        default: goto L2c;
+                    }
+                L2c:
+                    r0 = r5
+                    goto L57
+                L2e:
+                    java.lang.String r0 = "dismiss"
+                    boolean r0 = r1.equals(r0)
+                    if (r0 != 0) goto L37
+                    goto L2c
+                L37:
+                    r0 = 3
+                    goto L57
+                L39:
+                    java.lang.String r0 = "browser"
+                    boolean r0 = r1.equals(r0)
+                    if (r0 != 0) goto L42
+                    goto L2c
+                L42:
+                    r0 = 2
+                    goto L57
+                L44:
+                    java.lang.String r3 = "event"
+                    boolean r1 = r1.equals(r3)
+                    if (r1 != 0) goto L57
+                    goto L2c
+                L4d:
+                    java.lang.String r0 = "load_complete"
+                    boolean r0 = r1.equals(r0)
+                    if (r0 != 0) goto L56
+                    goto L2c
+                L56:
+                    r0 = r4
+                L57:
+                    switch(r0) {
+                        case 0: goto L6f;
+                        case 1: goto L69;
+                        case 2: goto L63;
+                        case 3: goto L5b;
+                        default: goto L5a;
+                    }
+                L5a:
+                    goto L74
+                L5b:
+                    r6.isInternalRedirect = r4
+                    csdk.glucentralservices.consent.ConsentUI r7 = csdk.glucentralservices.consent.ConsentUI.this
+                    csdk.glucentralservices.consent.ConsentUI.access$300(r7, r2)
+                    goto L74
+                L63:
+                    csdk.glucentralservices.consent.ConsentUI r0 = csdk.glucentralservices.consent.ConsentUI.this
+                    csdk.glucentralservices.consent.ConsentUI.access$400(r0, r7)
+                    goto L74
+                L69:
+                    csdk.glucentralservices.consent.ConsentUI r7 = csdk.glucentralservices.consent.ConsentUI.this
+                    csdk.glucentralservices.consent.ConsentUI.access$500(r7, r2)
+                    goto L74
+                L6f:
+                    csdk.glucentralservices.consent.ConsentUI r7 = csdk.glucentralservices.consent.ConsentUI.this
+                    csdk.glucentralservices.consent.ConsentUI.access$200(r7, r2)
+                L74:
+                    return
+                */
+                throw new UnsupportedOperationException("Method not decompiled: csdk.glucentralservices.consent.ConsentUI.AnonymousClass1.handleUrl(java.lang.String):void");
+            }
+        });
+    }
+
+    public void showConsent(String str, IConsentListener iConsentListener) {
+        AtomicReference<IConsentListener> atomicReference = this.mListener;
+        if (iConsentListener == null) {
+            iConsentListener = NullConsentListener.INSTANCE;
+        }
+        atomicReference.set(iConsentListener);
+        initConfig(str);
+        doShowConsent();
+        load();
+    }
+
+    private static String getApplicationName(Context context) {
+        return context.getApplicationInfo().loadLabel(context.getPackageManager()).toString();
+    }
+
+    private static String getAppIconURIString(Context context) {
+        Drawable applicationIcon = context.getPackageManager().getApplicationIcon(context.getApplicationInfo());
+        Bitmap createBitmap = Bitmap.createBitmap(applicationIcon.getIntrinsicWidth(), applicationIcon.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+        Canvas canvas = new Canvas(createBitmap);
+        applicationIcon.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
+        applicationIcon.draw(canvas);
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        createBitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream);
+        return "data:image/png;base64," + Base64.encodeToString(byteArrayOutputStream.toByteArray(), 0);
+    }
+
+    private static String createJavascriptCommandAndDismissOnError(String str, String str2) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            JSONObject jSONObject2 = new JSONObject();
+            jSONObject2.put("info", str2);
+            jSONObject.put("args", jSONObject2);
+            return "javascript:try{" + String.format("%s(%s)", str, jSONObject.toString()) + "}catch(e){window.location.href=\"consent://consent/?action=dismiss&status=Error%3A+\" + encodeURIComponent(e);}";
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    private void initConfig(String str) {
+        try {
+            this.mConfig = new JSONObject(str);
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    private void load() {
+        InputStream openStream;
+        String optString = this.mConfig.optString("consent_form_url", "file:///android_asset/consentform.html");
+        try {
+            if (optString.startsWith("file:///android_asset")) {
+                openStream = this.mActivity.getAssets().open("consentform.html");
+            } else {
+                openStream = FirebasePerfUrlConnection.openStream(new URL(optString));
+            }
+            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+            byte[] bArr = new byte[1024];
+            while (true) {
+                int read = openStream.read(bArr);
+                if (read != -1) {
+                    byteArrayOutputStream.write(bArr, 0, read);
+                } else {
+                    String byteArrayOutputStream2 = byteArrayOutputStream.toString("UTF-8");
+                    byteArrayOutputStream.close();
+                    this.mWebView.loadDataWithBaseURL("", byteArrayOutputStream2, "text/html", "UTF-8", null);
+                    return;
+                }
+            }
+        } catch (Exception e) {
+            onConsentStatusEventReceived(null, e);
+        }
+    }
+
+    private void doShowConsent() {
+        boolean optBoolean = this.mConfig.optBoolean("disableAgeGateHardwareAcceleration", false);
+        this.mDialog.getWindow().setLayout(-1, -1);
+        if (optBoolean) {
+            System.out.println("doShowConsent LAYER_TYPE_SOFTWARE");
+            this.mDialog.getWindow().getDecorView().setLayerType(1, null);
+        } else {
+            System.out.println("doShowConsent FLAG_HARDWARE_ACCELERATED");
+            this.mDialog.getWindow().setFlags(16777216, 16777216);
+        }
+        int i = Build.VERSION.SDK_INT;
+        this.mDialog.getWindow().setFlags(8, 8);
+        this.mDialog.getWindow().getDecorView().setSystemUiVisibility(4870);
+        if (i >= 28) {
+            WindowManager.LayoutParams attributes = this.mDialog.getWindow().getAttributes();
+            attributes.layoutInDisplayCutoutMode = 1;
+            this.mDialog.getWindow().setAttributes(attributes);
+        }
+        this.mDialog.getWindow().setBackgroundDrawable(new ColorDrawable(0));
+        this.mDialog.setOnShowListener(new DialogInterface.OnShowListener() { // from class: csdk.glucentralservices.consent.ConsentUI.2
+            @Override // android.content.DialogInterface.OnShowListener
+            public void onShow(DialogInterface dialogInterface) {
+            }
+        });
+        this.mDialog.show();
+        if (!this.mDialog.isShowing()) {
+            onConsentStatusEventReceived(null, new Exception("Consent form could not be displayed."));
+        }
+        this.mDialog.getWindow().clearFlags(8);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onConsentStatusEventReceived(String str, Throwable th) {
+        this.mListener.get().onConsentStatusReceived(str, th);
+        this.mListener.set(NullConsentListener.INSTANCE);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void updateDialogContent(WebView webView) {
+        JSONObject jSONObject = new JSONObject();
+        try {
+            JSONObject jSONObject2 = this.mConfig;
+            if (jSONObject2 != null) {
+                Iterator<String> keys = jSONObject2.keys();
+                while (keys.hasNext()) {
+                    String next = keys.next();
+                    jSONObject.put(next, jSONObject2.get(next));
+                }
+            }
+            String optString = jSONObject.optString(NativeProtocol.BRIDGE_ARG_APP_NAME_STRING);
+            String optString2 = jSONObject.optString("app_icon");
+            if (TextUtils.isEmpty(optString)) {
+                jSONObject.put(NativeProtocol.BRIDGE_ARG_APP_NAME_STRING, getApplicationName(this.mActivity));
+            }
+            if (TextUtils.isEmpty(optString2)) {
+                jSONObject.put("app_icon", getAppIconURIString(this.mActivity));
+            }
+            jSONObject.put("plat", "android");
+            webView.loadUrl(createJavascriptCommandAndDismissOnError("setUpConsentDialog", jSONObject.toString()));
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void handleLoadComplete(String str) {
+        if (TextUtils.isEmpty(str)) {
+            onConsentStatusEventReceived(null, new Exception("No information"));
+        } else if (str.contains("Error")) {
+            onConsentStatusEventReceived(null, new Exception(str));
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void handleOpenBrowser(String str) {
+        if (TextUtils.isEmpty(str)) {
+            onConsentStatusEventReceived(null, new Exception("No valid URL for browser navigation."));
+            return;
+        }
+        try {
+            this.mActivity.startActivity(new Intent("android.intent.action.VIEW", Uri.parse(str)));
+        } catch (ActivityNotFoundException unused) {
+            onConsentStatusEventReceived(null, new Exception("No Activity found to handle browser intent."));
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void handleDismiss(String str) {
+        this.mDialog.dismiss();
+        if (TextUtils.isEmpty(str)) {
+            onConsentStatusEventReceived(null, new Exception("No information provided."));
+        } else if (str.contains("Error")) {
+            onConsentStatusEventReceived(null, new Exception(str));
+        } else {
+            onConsentStatusEventReceived(str, null);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void handleEvent(String str) {
+        this.mListener.get().onConsentEventReceived(str);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityResumed(@NonNull Activity activity) {
+        Dialog dialog;
+        if (activity != this.mActivity || (dialog = this.mDialog) == null) {
+            return;
+        }
+        dialog.getWindow().getDecorView().setSystemUiVisibility(4870);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityDestroyed(@NonNull Activity activity) {
+        Dialog dialog;
+        if (activity == this.mActivity && (dialog = this.mDialog) != null && dialog.isShowing()) {
+            this.mDialog.dismiss();
+            this.mDialog = null;
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/consent/IConsentListener.java

@@ -0,0 +1,8 @@
+package csdk.glucentralservices.consent;
+
+/* loaded from: classes4.dex */
+public interface IConsentListener {
+    void onConsentEventReceived(String str);
+
+    void onConsentStatusReceived(String str, Throwable th);
+}

decompiled/sources/csdk/glucentralservices/consent/NullConsentListener.java

@@ -0,0 +1,14 @@
+package csdk.glucentralservices.consent;
+
+/* loaded from: classes4.dex */
+public class NullConsentListener implements IConsentListener {
+    public static final IConsentListener INSTANCE = new NullConsentListener();
+
+    @Override // csdk.glucentralservices.consent.IConsentListener
+    public void onConsentEventReceived(String str) {
+    }
+
+    @Override // csdk.glucentralservices.consent.IConsentListener
+    public void onConsentStatusReceived(String str, Throwable th) {
+    }
+}

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;
+    }
+}

decompiled/sources/csdk/glucentralservices/eventbus/CollectionUtil.java

@@ -0,0 +1,418 @@
+package csdk.glucentralservices.eventbus;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+import android.util.JsonReader;
+import android.util.JsonToken;
+import csdk.gluads.Consts;
+import java.io.StringReader;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+class CollectionUtil {
+    public static final IVisitor<Object> BUILDER_LIST;
+    public static final IVisitor<Object> BUILDER_MAP;
+    public static final IVisitor<Object> BUILDER_OUTER;
+    public static final IVisitor<JSONStringer> JSON_LIST;
+    public static final IVisitor<JSONStringer> JSON_MAP;
+    public static final IVisitor<JSONStringer> JSON_OUTER;
+
+    public interface IVisitor<S> {
+        Object beginList(S s, Object obj, String str) throws Exception;
+
+        Object beginMap(S s, Object obj, String str) throws Exception;
+
+        Object endList(S s, Object obj, String str, Object obj2) throws Exception;
+
+        Object endMap(S s, Object obj, String str, Object obj2) throws Exception;
+
+        IVisitor<S> list();
+
+        IVisitor<S> map();
+
+        Object val(S s, Object obj, String str, Object obj2) throws Exception;
+    }
+
+    static {
+        JSON_MAP = new JSONStringerMapVisitor();
+        JSONStringerListVisitor jSONStringerListVisitor = new JSONStringerListVisitor();
+        JSON_LIST = jSONStringerListVisitor;
+        JSON_OUTER = jSONStringerListVisitor;
+        BUILDER_MAP = new BuilderMapVisitor();
+        BUILDER_LIST = new BuilderListVisitor();
+        BUILDER_OUTER = new BuilderOuterVisitor();
+    }
+
+    public static Map<String, Object> parseJSON(String str) throws JSONException {
+        return Api11.parseJsonObject(str);
+    }
+
+    public static Map<String, Object> toMap(Object obj) {
+        try {
+            return (Map) visit(obj, BUILDER_OUTER, null, null, null);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String toJSON(Object obj) throws JSONException {
+        JSONStringer jSONStringer = new JSONStringer();
+        jsonValue(jSONStringer, obj);
+        return jSONStringer.toString();
+    }
+
+    public static void jsonValue(JSONStringer jSONStringer, Object obj) throws JSONException {
+        try {
+            visit(obj, JSON_OUTER, jSONStringer, null, null);
+        } catch (JSONException e) {
+            throw e;
+        } catch (Exception e2) {
+            throw new RuntimeException(e2);
+        }
+    }
+
+    public static <S> Object visit(Object obj, IVisitor<S> iVisitor, S s, Object obj2, String str) throws Exception {
+        if (obj == null || (obj instanceof Number) || (obj instanceof Boolean)) {
+            return iVisitor.val(s, obj2, str, obj);
+        }
+        if ((obj instanceof CharSequence) || (obj instanceof Character)) {
+            return iVisitor.val(s, obj2, str, obj.toString());
+        }
+        if (obj instanceof Map) {
+            return visitMap(iVisitor, s, obj2, str, (Map) obj);
+        }
+        if (obj instanceof Iterable) {
+            IVisitor<S> list = iVisitor.list();
+            Object beginList = iVisitor.beginList(s, obj2, str);
+            Iterator it = ((Iterable) obj).iterator();
+            while (it.hasNext()) {
+                beginList = visit(it.next(), list, s, beginList, null);
+            }
+            return iVisitor.endList(s, obj2, str, beginList);
+        }
+        int i = 0;
+        if (obj.getClass().isArray()) {
+            IVisitor<S> list2 = iVisitor.list();
+            Object beginList2 = iVisitor.beginList(s, obj2, str);
+            int length = Array.getLength(obj);
+            while (i < length) {
+                beginList2 = visit(Array.get(obj, i), list2, s, beginList2, null);
+                i++;
+            }
+            return iVisitor.endList(s, obj2, str, beginList2);
+        }
+        if (obj instanceof Bundle) {
+            IVisitor<S> map = iVisitor.map();
+            Object beginMap = iVisitor.beginMap(s, obj2, str);
+            Bundle bundle = (Bundle) obj;
+            Iterator<String> it2 = bundle.keySet().iterator();
+            while (it2.hasNext()) {
+                beginMap = visit(bundle.get(str), map, s, beginMap, it2.next());
+            }
+            return iVisitor.endMap(s, obj2, str, beginMap);
+        }
+        if (obj instanceof JSONArray) {
+            IVisitor<S> list3 = iVisitor.list();
+            Object beginList3 = iVisitor.beginList(s, obj2, str);
+            JSONArray jSONArray = (JSONArray) obj;
+            while (i < jSONArray.length()) {
+                beginList3 = visit(jSONArray.opt(i), list3, s, beginList3, null);
+                i++;
+            }
+            return iVisitor.endList(s, obj2, str, beginList3);
+        }
+        if (obj instanceof JSONObject) {
+            IVisitor<S> map2 = iVisitor.map();
+            Object beginMap2 = iVisitor.beginMap(s, obj2, str);
+            JSONObject jSONObject = (JSONObject) obj;
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                beginMap2 = visit(jSONObject.opt(str), map2, s, beginMap2, keys.next());
+            }
+            return iVisitor.endMap(s, obj2, str, beginMap2);
+        }
+        if (obj == JSONObject.NULL) {
+            return iVisitor.val(s, obj2, str, null);
+        }
+        IVisitor<S> map3 = iVisitor.map();
+        Object visit = visit(obj.getClass().getSimpleName(), map3, s, iVisitor.beginMap(s, obj2, str), "cls");
+        String collectionUtil = toString(obj);
+        if (collectionUtil != null) {
+            visit = visit(collectionUtil, map3, s, visit, "str");
+        }
+        return iVisitor.endMap(s, obj2, str, visit);
+    }
+
+    private static <S> Object visitMap(IVisitor<S> iVisitor, S s, Object obj, String str, Map<?, ?> map) throws Exception {
+        Iterator<?> it = map.keySet().iterator();
+        while (it.hasNext()) {
+            if (!(it.next() instanceof CharSequence)) {
+                return visitMapWithNonStringKeys(iVisitor, s, obj, str, map);
+            }
+        }
+        IVisitor<S> map2 = iVisitor.map();
+        Object beginMap = iVisitor.beginMap(s, obj, str);
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            beginMap = visit(entry.getValue(), map2, s, beginMap, entry.getKey().toString());
+        }
+        return iVisitor.endMap(s, obj, str, beginMap);
+    }
+
+    private static <S> Object visitMapWithNonStringKeys(IVisitor<S> iVisitor, S s, Object obj, String str, Map<?, ?> map) throws Exception {
+        IVisitor<S> map2 = iVisitor.map();
+        Object visit = visit("flatmap", map2, s, iVisitor.beginMap(s, obj, str), "cls");
+        IVisitor<S> list = iVisitor.list();
+        Object beginList = map2.beginList(s, visit, Consts.KEY_TAPJOY_USER_ID_VERSION);
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            visit(entry.getKey(), list, s, beginList, null);
+            visit(entry.getValue(), list, s, beginList, null);
+        }
+        map2.endList(s, visit, Consts.KEY_TAPJOY_USER_ID_VERSION, beginList);
+        return iVisitor.endMap(s, obj, str, visit);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static <K, V> Map<K, V> createMap() {
+        return new HashMap();
+    }
+
+    private static String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        if (obj instanceof Throwable) {
+            return ((Throwable) obj).getMessage();
+        }
+        return obj.toString();
+    }
+
+    public static abstract class JSONStringerBaseVisitor implements IVisitor<JSONStringer> {
+        private JSONStringerBaseVisitor() {
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object endMap(JSONStringer jSONStringer, Object obj, String str, Object obj2) throws JSONException {
+            return jSONStringer.endObject();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object endList(JSONStringer jSONStringer, Object obj, String str, Object obj2) throws JSONException {
+            return jSONStringer.endArray();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public IVisitor<JSONStringer> map() {
+            return CollectionUtil.JSON_MAP;
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public IVisitor<JSONStringer> list() {
+            return CollectionUtil.JSON_LIST;
+        }
+    }
+
+    public static class JSONStringerMapVisitor extends JSONStringerBaseVisitor {
+        private JSONStringerMapVisitor() {
+            super();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginMap(JSONStringer jSONStringer, Object obj, String str) throws JSONException {
+            return jSONStringer.key(str).object();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginList(JSONStringer jSONStringer, Object obj, String str) throws JSONException {
+            return jSONStringer.key(str).array();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(JSONStringer jSONStringer, Object obj, String str, Object obj2) throws JSONException {
+            return jSONStringer.key(str).value(obj2);
+        }
+    }
+
+    public static class JSONStringerListVisitor extends JSONStringerBaseVisitor {
+        private JSONStringerListVisitor() {
+            super();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginMap(JSONStringer jSONStringer, Object obj, String str) throws JSONException {
+            return jSONStringer.object();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginList(JSONStringer jSONStringer, Object obj, String str) throws JSONException {
+            return jSONStringer.array();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(JSONStringer jSONStringer, Object obj, String str, Object obj2) throws JSONException {
+            return jSONStringer.value(obj2);
+        }
+    }
+
+    public static abstract class BuilderBaseVisitor implements IVisitor<Object> {
+        private BuilderBaseVisitor() {
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginMap(Object obj, Object obj2, String str) {
+            return CollectionUtil.createMap();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object endMap(Object obj, Object obj2, String str, Object obj3) throws Exception {
+            return val(obj, obj2, str, obj3);
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginList(Object obj, Object obj2, String str) {
+            return new ArrayList();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object endList(Object obj, Object obj2, String str, Object obj3) throws Exception {
+            return val(obj, obj2, str, obj3);
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public IVisitor<Object> map() {
+            return CollectionUtil.BUILDER_MAP;
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public IVisitor<Object> list() {
+            return CollectionUtil.BUILDER_LIST;
+        }
+    }
+
+    public static class BuilderMapVisitor extends BuilderBaseVisitor {
+        private BuilderMapVisitor() {
+            super();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(Object obj, Object obj2, String str, Object obj3) {
+            Map map = (Map) obj2;
+            map.put(str, obj3);
+            return map;
+        }
+    }
+
+    public static class BuilderListVisitor extends BuilderBaseVisitor {
+        private BuilderListVisitor() {
+            super();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(Object obj, Object obj2, String str, Object obj3) {
+            List list = (List) obj2;
+            list.add(obj3);
+            return list;
+        }
+    }
+
+    public static class BuilderOuterVisitor extends BuilderBaseVisitor {
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(Object obj, Object obj2, String str, Object obj3) {
+            return obj3;
+        }
+
+        private BuilderOuterVisitor() {
+            super();
+        }
+    }
+
+    @TargetApi(11)
+    public static class Api11 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            return (Map) parseJsonValue(str, CollectionUtil.BUILDER_OUTER, null);
+        }
+
+        public static <S> Object parseJsonValue(String str, IVisitor<S> iVisitor, S s) throws JSONException {
+            try {
+                JsonReader jsonReader = new JsonReader(new StringReader(str));
+                jsonReader.setLenient(true);
+                return parseJsonValue(jsonReader, iVisitor, s, null, null);
+            } catch (JSONException e) {
+                throw e;
+            } catch (Exception e2) {
+                throw new RuntimeException(e2);
+            }
+        }
+
+        public static <S> Object parseJsonValue(JsonReader jsonReader, IVisitor<S> iVisitor, S s, Object obj, String str) throws Exception {
+            JsonToken peek = jsonReader.peek();
+            if (peek == JsonToken.BEGIN_OBJECT) {
+                return parseJsonObject(jsonReader, iVisitor, s, obj, str);
+            }
+            if (peek == JsonToken.BEGIN_ARRAY) {
+                return parseJsonArray(jsonReader, iVisitor, s, obj, str);
+            }
+            if (peek == JsonToken.BOOLEAN) {
+                return iVisitor.val(s, obj, str, Boolean.valueOf(jsonReader.nextBoolean()));
+            }
+            if (peek == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return iVisitor.val(s, obj, str, null);
+            }
+            if (peek == JsonToken.NUMBER) {
+                String nextString = jsonReader.nextString();
+                if (nextString.contains(Consts.STRING_PERIOD) || nextString.contains("e") || nextString.contains("E")) {
+                    return iVisitor.val(s, obj, str, Double.valueOf(Double.parseDouble(nextString)));
+                }
+                return iVisitor.val(s, obj, str, Long.valueOf(Long.parseLong(nextString)));
+            }
+            if (peek == JsonToken.STRING) {
+                return iVisitor.val(s, obj, str, jsonReader.nextString());
+            }
+            throw new JSONException("Unexpected token " + peek);
+        }
+
+        public static <S> Object parseJsonObject(JsonReader jsonReader, IVisitor<S> iVisitor, S s, Object obj, String str) throws Exception {
+            jsonReader.beginObject();
+            IVisitor<S> map = iVisitor.map();
+            Object beginMap = iVisitor.beginMap(s, obj, str);
+            while (true) {
+                JsonToken peek = jsonReader.peek();
+                if (peek == JsonToken.END_OBJECT) {
+                    jsonReader.endObject();
+                    return iVisitor.endMap(s, obj, str, beginMap);
+                }
+                if (peek == JsonToken.NAME) {
+                    beginMap = parseJsonValue(jsonReader, map, s, beginMap, jsonReader.nextName());
+                } else {
+                    throw new JSONException("Expected } or name but found " + peek);
+                }
+            }
+        }
+
+        public static <S> Object parseJsonArray(JsonReader jsonReader, IVisitor<S> iVisitor, S s, Object obj, String str) throws Exception {
+            jsonReader.beginArray();
+            IVisitor<S> list = iVisitor.list();
+            Object beginList = iVisitor.beginList(s, obj, str);
+            while (jsonReader.peek() != JsonToken.END_ARRAY) {
+                beginList = parseJsonValue(jsonReader, list, s, beginList, null);
+            }
+            jsonReader.endArray();
+            return iVisitor.endList(s, obj, str, beginList);
+        }
+    }
+
+    public static class Api1 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            return CollectionUtil.toMap(new JSONObject(str));
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/eventbus/EventHandlerData.java

@@ -0,0 +1,12 @@
+package csdk.glucentralservices.eventbus;
+
+/* loaded from: classes4.dex */
+class EventHandlerData {
+    public final IServerEventBus eventBus;
+    public final IServerEventHandler handler;
+
+    public EventHandlerData(IServerEventBus iServerEventBus, IServerEventHandler iServerEventHandler) {
+        this.eventBus = iServerEventBus;
+        this.handler = iServerEventHandler;
+    }
+}

decompiled/sources/csdk/glucentralservices/eventbus/GluEventBus.java

@@ -0,0 +1,243 @@
+package csdk.glucentralservices.eventbus;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+public abstract class GluEventBus {
+    public static final GluEventBus DISCONNECTED = new DisconnectedEventBus();
+    private static final String EVT_ACTION = "action";
+    private static final String EVT_CHANNEL = "channel";
+    private static final String EVT_DATA = "data";
+    private static final String EVT_SENDER = "sender";
+    public static final Object GLOBAL_TOKEN;
+    private static final Set<String> KEYS;
+    public static final GluEventBus SHARED;
+
+    public interface IEventHandler {
+        void handleEvent(GluEventBus gluEventBus, Object obj, String str, Event event) throws Exception;
+    }
+
+    public abstract Object globalToken();
+
+    public abstract boolean isConnected();
+
+    public abstract void publish(Object obj, Event event);
+
+    public abstract Object subscribe(Object obj, String str, Collection<String> collection, IEventHandler iEventHandler);
+
+    public abstract void unsubscribe(Object obj);
+
+    static {
+        GluEventBus createEventBus = createEventBus();
+        SHARED = createEventBus;
+        GLOBAL_TOKEN = createEventBus.globalToken();
+        KEYS = createKeys();
+    }
+
+    private static GluEventBus createEventBus() {
+        try {
+            return new RealEventBus(ServerEventBus.getShared());
+        } catch (NoClassDefFoundError unused) {
+            return DISCONNECTED;
+        }
+    }
+
+    private static Set<String> createKeys() {
+        HashSet hashSet = new HashSet();
+        hashSet.add("channel");
+        hashSet.add("action");
+        hashSet.add(EVT_SENDER);
+        hashSet.add("data");
+        return hashSet;
+    }
+
+    public static class Event implements Map<String, Object> {
+        public String action;
+        public String channel;
+        public Map<String, Object> data;
+        public String sender;
+
+        public Event() {
+        }
+
+        public Event(String str, String str2, String str3, Map<String, Object> map) {
+            this.channel = str;
+            this.action = str2;
+            this.sender = str3;
+            this.data = map;
+        }
+
+        @Override // java.util.Map
+        public int size() {
+            return keySet().size();
+        }
+
+        @Override // java.util.Map
+        public boolean isEmpty() {
+            return size() == 0;
+        }
+
+        @Override // java.util.Map
+        public boolean containsKey(Object obj) {
+            return GluEventBus.KEYS.contains(obj);
+        }
+
+        @Override // java.util.Map
+        public boolean containsValue(Object obj) {
+            return values().contains(obj);
+        }
+
+        @Override // java.util.Map
+        public Object get(Object obj) {
+            if (obj == null) {
+                return null;
+            }
+            if (obj.equals("channel")) {
+                return this.channel;
+            }
+            if (obj.equals("action")) {
+                return this.action;
+            }
+            if (obj.equals(GluEventBus.EVT_SENDER)) {
+                return this.sender;
+            }
+            if (obj.equals("data")) {
+                return this.data;
+            }
+            return null;
+        }
+
+        @Override // java.util.Map
+        public Object put(String str, Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public Object remove(Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public void putAll(@NonNull Map<? extends String, ? extends Object> map) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public void clear() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Set<String> keySet() {
+            return GluEventBus.KEYS;
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Collection<Object> values() {
+            return Arrays.asList(this.channel, this.action, this.sender, this.data);
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Set<Map.Entry<String, Object>> entrySet() {
+            HashSet hashSet = new HashSet();
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("channel", this.channel));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("action", this.action));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry(GluEventBus.EVT_SENDER, this.sender));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("data", this.data));
+            return hashSet;
+        }
+    }
+
+    public static class DisconnectedEventBus extends GluEventBus {
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public Object globalToken() {
+            return this;
+        }
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public boolean isConnected() {
+            return false;
+        }
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+        }
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+        }
+
+        private DisconnectedEventBus() {
+        }
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public Object subscribe(Object obj, String str, Collection<String> collection, IEventHandler iEventHandler) {
+            if (iEventHandler != null) {
+                try {
+                    iEventHandler.handleEvent(this, obj, str, new Event("#me", "unsubscribed", "@eb.disconnected", null));
+                } catch (Exception e) {
+                    Log.e("DisconnectedEventBus", "Failed to destroy handler", e);
+                }
+            }
+            return null;
+        }
+    }
+
+    public static class RealEventBus extends GluEventBus {
+        private final IServerEventBus mEventBus;
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public boolean isConnected() {
+            return true;
+        }
+
+        public RealEventBus(IServerEventBus iServerEventBus) {
+            this.mEventBus = iServerEventBus;
+        }
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public Object subscribe(Object obj, String str, Collection<String> collection, final IEventHandler iEventHandler) {
+            return this.mEventBus.subscribe(obj, str, collection, iEventHandler != null ? new IServerEventHandler() { // from class: csdk.glucentralservices.eventbus.GluEventBus.RealEventBus.1
+                @Override // csdk.glucentralservices.eventbus.IServerEventHandler
+                public void handleEvent(IServerEventBus iServerEventBus, Object obj2, String str2, Map<String, Object> map) throws Exception {
+                    Event event;
+                    if (map != null) {
+                        event = new Event();
+                        event.channel = (String) map.get("channel");
+                        event.action = (String) map.get("action");
+                        event.sender = (String) map.get(GluEventBus.EVT_SENDER);
+                        event.data = (Map) map.get("data");
+                    } else {
+                        event = null;
+                    }
+                    iEventHandler.handleEvent(RealEventBus.this, obj2, str2, event);
+                }
+            } : null);
+        }
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+            this.mEventBus.unsubscribe(obj);
+        }
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+            this.mEventBus.publish(obj, event);
+        }
+
+        @Override // csdk.glucentralservices.eventbus.GluEventBus
+        public Object globalToken() {
+            return this.mEventBus.globalToken();
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/eventbus/IServerEventBus.java

@@ -0,0 +1,15 @@
+package csdk.glucentralservices.eventbus;
+
+import java.util.Collection;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface IServerEventBus {
+    Object globalToken();
+
+    void publish(Object obj, Map<String, Object> map);
+
+    Object subscribe(Object obj, String str, Collection<String> collection, IServerEventHandler iServerEventHandler);
+
+    void unsubscribe(Object obj);
+}

decompiled/sources/csdk/glucentralservices/eventbus/IServerEventHandler.java

@@ -0,0 +1,8 @@
+package csdk.glucentralservices.eventbus;
+
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface IServerEventHandler {
+    void handleEvent(IServerEventBus iServerEventBus, Object obj, String str, Map<String, Object> map) throws Exception;
+}

decompiled/sources/csdk/glucentralservices/eventbus/ServerEvent.java

@@ -0,0 +1,118 @@
+package csdk.glucentralservices.eventbus;
+
+import androidx.annotation.NonNull;
+import com.firemonkeys.cloudcellapi.LocalNotificationsCenter;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+class ServerEvent implements Map<String, Object> {
+    private static final Set<String> KEYS = createKeys();
+    public final String action;
+    public final String channel;
+    public final Map<String, Object> data;
+    public final String sender;
+
+    @Override // java.util.Map
+    @NonNull
+    public Set<String> keySet() {
+        return KEYS;
+    }
+
+    public ServerEvent(String str, String str2, String str3, Map<String, Object> map) {
+        this.channel = str;
+        this.action = str2;
+        this.sender = str3;
+        this.data = map;
+    }
+
+    @Override // java.util.Map
+    public int size() {
+        return keySet().size();
+    }
+
+    @Override // java.util.Map
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    @Override // java.util.Map
+    public boolean containsKey(Object obj) {
+        return KEYS.contains(obj);
+    }
+
+    @Override // java.util.Map
+    public boolean containsValue(Object obj) {
+        return values().contains(obj);
+    }
+
+    @Override // java.util.Map
+    public Object get(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        if (obj.equals(LocalNotificationsCenter.EXTRA_CHANNEL_ID)) {
+            return this.channel;
+        }
+        if (obj.equals("action")) {
+            return this.action;
+        }
+        if (obj.equals("sender")) {
+            return this.sender;
+        }
+        if (obj.equals("data")) {
+            return this.data;
+        }
+        return null;
+    }
+
+    @Override // java.util.Map
+    public Object put(String str, Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Map
+    public Object remove(Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Map
+    public void putAll(@NonNull Map<? extends String, ? extends Object> map) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Map
+    public void clear() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Map
+    @NonNull
+    public Collection<Object> values() {
+        return Arrays.asList(this.channel, this.action, this.sender, this.data);
+    }
+
+    @Override // java.util.Map
+    @NonNull
+    public Set<Map.Entry<String, Object>> entrySet() {
+        HashSet hashSet = new HashSet();
+        hashSet.add(new AbstractMap.SimpleImmutableEntry(LocalNotificationsCenter.EXTRA_CHANNEL_ID, this.channel));
+        hashSet.add(new AbstractMap.SimpleImmutableEntry("action", this.action));
+        hashSet.add(new AbstractMap.SimpleImmutableEntry("sender", this.sender));
+        hashSet.add(new AbstractMap.SimpleImmutableEntry("data", this.data));
+        return hashSet;
+    }
+
+    private static Set<String> createKeys() {
+        HashSet hashSet = new HashSet();
+        hashSet.add(LocalNotificationsCenter.EXTRA_CHANNEL_ID);
+        hashSet.add("action");
+        hashSet.add("sender");
+        hashSet.add("data");
+        return hashSet;
+    }
+}

decompiled/sources/csdk/glucentralservices/eventbus/ServerEventBus.java

@@ -0,0 +1,178 @@
+package csdk.glucentralservices.eventbus;
+
+import android.text.TextUtils;
+import com.firemonkeys.cloudcellapi.LocalNotificationsCenter;
+import java.util.Collection;
+import java.util.Map;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class ServerEventBus implements IServerEventBus {
+    private static final int RES_BAD_JSON_DATA = 2;
+    private static final int RES_ERROR = 3;
+    private static final int RES_OK = 0;
+    private static final ServerEventBus SHARED = createShared();
+    private final long mEventBus;
+    private final Object mGlobalToken;
+    private final long mMIDHandleEvent = getMIDHandleEvent();
+
+    private static native long getMIDHandleEvent();
+
+    public static IServerEventBus getShared() {
+        return SHARED;
+    }
+
+    private static native long globalToken(long j);
+
+    private static native void publish(long j, long j2, String str, String str2, String str3, String str4);
+
+    private static native void publishError(long j, long j2, String str, String str2, String str3, String str4, String str5, String str6, String str7);
+
+    private static native long shared();
+
+    private static native long subscribe(long j, long j2, long j3, String str, String[] strArr, EventHandlerData eventHandlerData);
+
+    private static native void unsubscribe(long j, long j2);
+
+    @Override // csdk.glucentralservices.eventbus.IServerEventBus
+    public Object globalToken() {
+        return this.mGlobalToken;
+    }
+
+    private ServerEventBus(long j) {
+        this.mEventBus = j;
+        this.mGlobalToken = tokenFromNativeToken(globalToken(j));
+    }
+
+    @Override // csdk.glucentralservices.eventbus.IServerEventBus
+    public Object subscribe(Object obj, String str, Collection<String> collection, IServerEventHandler iServerEventHandler) {
+        String[] strArr;
+        if (collection != null) {
+            strArr = new String[collection.size()];
+            collection.toArray(strArr);
+        } else {
+            strArr = null;
+        }
+        return tokenFromNativeToken(subscribe(this.mEventBus, nativeTokenFromToken(obj), this.mMIDHandleEvent, str, strArr, new EventHandlerData(this, iServerEventHandler)));
+    }
+
+    @Override // csdk.glucentralservices.eventbus.IServerEventBus
+    public void unsubscribe(Object obj) {
+        unsubscribe(this.mEventBus, nativeTokenFromToken(obj));
+    }
+
+    @Override // csdk.glucentralservices.eventbus.IServerEventBus
+    public void publish(Object obj, Map<String, Object> map) {
+        Exception exc;
+        String str;
+        String str2;
+        String str3;
+        String json;
+        String str4;
+        String str5;
+        String str6;
+        if (map != null) {
+            try {
+                String str7 = (String) map.get(LocalNotificationsCenter.EXTRA_CHANNEL_ID);
+                try {
+                    String str8 = (String) map.get("action");
+                    try {
+                        String str9 = (String) map.get("sender");
+                        try {
+                            Map map2 = (Map) map.get("data");
+                            json = map2 != null ? CollectionUtil.toJSON(map2) : null;
+                            str4 = str7;
+                            str5 = str8;
+                            str6 = str9;
+                        } catch (Exception e) {
+                            exc = e;
+                            str = str7;
+                            str2 = str8;
+                            str3 = str9;
+                            publishError(this.mEventBus, nativeTokenFromToken(obj), null, exc, str, str2, str3, null);
+                            return;
+                        }
+                    } catch (Exception e2) {
+                        exc = e2;
+                        str3 = null;
+                        str = str7;
+                        str2 = str8;
+                    }
+                } catch (Exception e3) {
+                    exc = e3;
+                    str2 = null;
+                    str3 = null;
+                    str = str7;
+                }
+            } catch (Exception e4) {
+                exc = e4;
+                str = null;
+                str2 = null;
+                str3 = null;
+            }
+        } else {
+            str4 = null;
+            str5 = null;
+            str6 = null;
+            json = null;
+        }
+        publish(this.mEventBus, nativeTokenFromToken(obj), str4, str5, str6, json);
+    }
+
+    private static ServerEventBus createShared() {
+        try {
+            System.loadLibrary("glucentralservices");
+        } catch (UnsatisfiedLinkError unused) {
+        }
+        return new ServerEventBus(shared());
+    }
+
+    private static int handleEvent(long j, long j2, String str, String str2, String str3, String str4, String str5, EventHandlerData eventHandlerData) {
+        try {
+            return doHandleEvent(j, j2, str, str2, str3, str4, str5, eventHandlerData);
+        } catch (Exception e) {
+            publishError(j, j2, str, "critical", e.getMessage(), str2, str3, str4, str5);
+            return 3;
+        }
+    }
+
+    private static int doHandleEvent(long j, long j2, String str, String str2, String str3, String str4, String str5, EventHandlerData eventHandlerData) throws Exception {
+        Map<String, Object> parseJSON;
+        if (TextUtils.isEmpty(str5)) {
+            parseJSON = null;
+        } else {
+            try {
+                parseJSON = CollectionUtil.parseJSON(str5);
+            } catch (JSONException unused) {
+                return 2;
+            }
+        }
+        try {
+        } catch (Exception e) {
+            e = e;
+        }
+        try {
+            eventHandlerData.handler.handleEvent(eventHandlerData.eventBus, tokenFromNativeToken(j2), str, new ServerEvent(str2, str3, str4, parseJSON));
+            return 0;
+        } catch (Exception e2) {
+            e = e2;
+            publishError(j, j2, str, e, str2, str3, str4, str5);
+            return 3;
+        }
+    }
+
+    private static Object tokenFromNativeToken(long j) {
+        return Long.valueOf(j);
+    }
+
+    private static long nativeTokenFromToken(Object obj) {
+        if (obj != null) {
+            return ((Long) obj).longValue();
+        }
+        return 0L;
+    }
+
+    private static void publishError(long j, long j2, String str, Throwable th, String str2, String str3, String str4, String str5) {
+        publishError(j, j2, str, th.getClass().getName(), th.getMessage(), str2, str3, str4, str5);
+    }
+}

decompiled/sources/csdk/glucentralservices/kvstore/StringStore.java

@@ -0,0 +1,117 @@
+package csdk.glucentralservices.kvstore;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/* loaded from: classes4.dex */
+public class StringStore {
+    private static volatile StringStore sInstance;
+    private HashMap<String, String> mStore = new HashMap<>();
+    private HashSet<String> mInitializedPlugins = new HashSet<>();
+    private ReadWriteLock mLock = new ReentrantReadWriteLock();
+    private final HashSet<String> mPluginNames = new HashSet<String>() { // from class: csdk.glucentralservices.kvstore.StringStore.1
+        {
+            add("gluads");
+            add("gluanalytics");
+            add("gluapptracking");
+            add("glucentralservices");
+            add("gluiap");
+            add("glumarketing");
+            add("glucustomersupport");
+            add("starlightsecurity");
+        }
+    };
+    private final HashMap<String, SetStringHandler> mHandlers = new HashMap<String, SetStringHandler>() { // from class: csdk.glucentralservices.kvstore.StringStore.2
+        {
+            put("*init", new SetStringHandler() { // from class: csdk.glucentralservices.kvstore.StringStore.2.1
+                @Override // csdk.glucentralservices.kvstore.StringStore.SetStringHandler
+                public void process(String str) {
+                    if (StringStore.this.mPluginNames.contains(str)) {
+                        if (!StringStore.this.mInitializedPlugins.contains(str)) {
+                            StringStore.this.mInitializedPlugins.add(str);
+                            return;
+                        }
+                        StringBuilder sb = new StringBuilder();
+                        sb.append(str);
+                        sb.append(" is already initialized");
+                        return;
+                    }
+                    StringBuilder sb2 = new StringBuilder();
+                    sb2.append("Unsupported plugin: ");
+                    sb2.append(str);
+                }
+            });
+            put("*destroy", new SetStringHandler() { // from class: csdk.glucentralservices.kvstore.StringStore.2.2
+                @Override // csdk.glucentralservices.kvstore.StringStore.SetStringHandler
+                public void process(String str) {
+                    if (StringStore.this.mPluginNames.contains(str)) {
+                        if (StringStore.this.mInitializedPlugins.contains(str)) {
+                            StringStore.this.mInitializedPlugins.remove(str);
+                        } else {
+                            StringBuilder sb = new StringBuilder();
+                            sb.append(str);
+                            sb.append(" has not been initialized");
+                        }
+                        if (StringStore.this.mInitializedPlugins.size() == 0) {
+                            StringStore.this.mStore.clear();
+                            return;
+                        }
+                        return;
+                    }
+                    StringBuilder sb2 = new StringBuilder();
+                    sb2.append("Unsupported plugin: ");
+                    sb2.append(str);
+                }
+            });
+        }
+    };
+
+    public interface SetStringHandler {
+        void process(String str);
+    }
+
+    private static StringStore Instance() {
+        if (sInstance == null) {
+            synchronized (StringStore.class) {
+                try {
+                    if (sInstance == null) {
+                        sInstance = new StringStore();
+                    }
+                } finally {
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    private StringStore() {
+    }
+
+    private String getValue(String str) {
+        this.mLock.readLock().lock();
+        String str2 = this.mStore.get(str);
+        this.mLock.readLock().unlock();
+        return str2;
+    }
+
+    private void setKeyValue(String str, String str2) {
+        this.mLock.writeLock().lock();
+        SetStringHandler setStringHandler = this.mHandlers.get(str);
+        if (setStringHandler == null) {
+            this.mStore.put(str, str2);
+        } else {
+            setStringHandler.process(str2);
+        }
+        this.mLock.writeLock().unlock();
+    }
+
+    public static String get(String str) {
+        return Instance().getValue(str);
+    }
+
+    public static void set(String str, String str2) {
+        Instance().setKeyValue(str, str2);
+    }
+}

decompiled/sources/csdk/glucentralservices/network/DownloadInfo.java

@@ -0,0 +1,18 @@
+package csdk.glucentralservices.network;
+
+import csdk.glucentralservices.network.Downloader;
+
+/* loaded from: classes4.dex */
+public class DownloadInfo {
+    public final String destinationPath;
+    public final long downloadID;
+    public final Downloader.DownloadListener listener;
+    public final String sourcePath;
+
+    public DownloadInfo(long j, String str, String str2, Downloader.DownloadListener downloadListener) {
+        this.downloadID = j;
+        this.sourcePath = str;
+        this.destinationPath = str2;
+        this.listener = downloadListener;
+    }
+}

decompiled/sources/csdk/glucentralservices/network/Downloader.java

@@ -0,0 +1,226 @@
+package csdk.glucentralservices.network;
+
+import android.app.DownloadManager;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.database.Cursor;
+import android.net.Uri;
+import android.text.TextUtils;
+import com.facebook.share.internal.ShareConstants;
+import com.vungle.ads.internal.presenter.NativeAdPresenter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes4.dex */
+public class Downloader {
+    private final Context mContext;
+    private final Map<Long, DownloadInfo> mDownloadInfoMap = new ConcurrentHashMap();
+    private final DownloadManager mDownloadManager;
+    private BroadcastReceiver mReceiver;
+
+    public interface DownloadListener {
+        void onDownloadComplete(boolean z, DownloadInfo downloadInfo);
+    }
+
+    public Downloader(Context context) {
+        this.mContext = context;
+        this.mDownloadManager = (DownloadManager) context.getSystemService(NativeAdPresenter.DOWNLOAD);
+    }
+
+    public void init() {
+        this.mReceiver = new DownloadReceiver();
+        this.mContext.registerReceiver(this.mReceiver, new IntentFilter("android.intent.action.DOWNLOAD_COMPLETE"), 2);
+    }
+
+    public void destroy() {
+        BroadcastReceiver broadcastReceiver = this.mReceiver;
+        if (broadcastReceiver != null) {
+            this.mContext.unregisterReceiver(broadcastReceiver);
+        }
+    }
+
+    public void download(String str, String str2, DownloadListener downloadListener) {
+        long downloadID = getDownloadID(Uri.parse(str));
+        DownloadInfo downloadInfo = new DownloadInfo(downloadID, str, str2, downloadListener);
+        if (downloadID >= 0) {
+            int downloadStatus = downloadStatus(downloadID);
+            if (downloadStatus == 8) {
+                boolean copyToDestination = copyToDestination(downloadInfo);
+                deleteDownload(downloadID);
+                if (copyToDestination) {
+                    onDownloadComplete(true, downloadInfo);
+                    return;
+                }
+            } else if (downloadStatus == 1 || downloadStatus == 2) {
+                return;
+            }
+        }
+        if (startDownload(downloadInfo)) {
+            return;
+        }
+        onDownloadComplete(false, downloadInfo);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void onDownloadComplete(boolean z, DownloadInfo downloadInfo) throws SecurityException {
+        DownloadListener downloadListener = downloadInfo.listener;
+        if (downloadListener != null) {
+            downloadListener.onDownloadComplete(z, downloadInfo);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public boolean copyToDestination(DownloadInfo downloadInfo) {
+        String str;
+        InputStream fileInputStream;
+        Cursor query = this.mDownloadManager.query(new DownloadManager.Query().setFilterById(downloadInfo.downloadID));
+        if (query == null) {
+            return false;
+        }
+        try {
+            if (!query.moveToFirst()) {
+                return false;
+            }
+            Uri parse = Uri.parse(query.getString(query.getColumnIndex("local_uri")));
+            InputStream inputStream = null;
+            try {
+                str = query.getString(query.getColumnIndex("local_filename"));
+            } catch (Exception unused) {
+                str = null;
+            }
+            query.close();
+            try {
+                try {
+                    fileInputStream = this.mContext.getContentResolver().openInputStream(parse);
+                } catch (SecurityException unused2) {
+                    fileInputStream = new FileInputStream(str);
+                }
+                inputStream = fileInputStream;
+                new File(downloadInfo.destinationPath).getParentFile().mkdirs();
+                NetworkUtils.copyIntoFile(inputStream, new File(downloadInfo.destinationPath));
+                if (inputStream != null) {
+                    try {
+                        inputStream.close();
+                    } catch (IOException unused3) {
+                    }
+                }
+                return true;
+            } catch (IOException unused4) {
+                if (inputStream != null) {
+                    try {
+                        inputStream.close();
+                    } catch (IOException unused5) {
+                    }
+                }
+                return false;
+            } catch (Exception unused6) {
+                if (inputStream != null) {
+                    try {
+                        inputStream.close();
+                    } catch (IOException unused7) {
+                    }
+                }
+                return false;
+            } catch (Throwable th) {
+                if (inputStream != null) {
+                    try {
+                        inputStream.close();
+                    } catch (IOException unused8) {
+                    }
+                }
+                throw th;
+            }
+        } finally {
+            query.close();
+        }
+    }
+
+    private boolean startDownload(DownloadInfo downloadInfo) {
+        try {
+            long enqueue = this.mDownloadManager.enqueue(new DownloadManager.Request(Uri.parse(downloadInfo.sourcePath)).setVisibleInDownloadsUi(false));
+            this.mDownloadInfoMap.put(Long.valueOf(enqueue), new DownloadInfo(enqueue, downloadInfo.sourcePath, downloadInfo.destinationPath, downloadInfo.listener));
+            return true;
+        } catch (IllegalArgumentException unused) {
+            return false;
+        }
+    }
+
+    private long getDownloadID(Uri uri) {
+        Cursor query = this.mDownloadManager.query(new DownloadManager.Query());
+        long j = -1;
+        if (query == null) {
+            return -1L;
+        }
+        try {
+            if (query.moveToFirst()) {
+                String uri2 = uri.toString();
+                int columnIndex = query.getColumnIndex(ShareConstants.MEDIA_URI);
+                int columnIndex2 = query.getColumnIndex("_id");
+                do {
+                    if (TextUtils.equals(uri2, query.getString(columnIndex))) {
+                        j = Math.max(query.getLong(columnIndex2), j);
+                    }
+                } while (query.moveToNext());
+                query.close();
+                return j;
+            }
+            query.close();
+            return -1L;
+        } catch (Throwable th) {
+            query.close();
+            throw th;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public int downloadStatus(long j) {
+        Cursor query = this.mDownloadManager.query(new DownloadManager.Query().setFilterById(j));
+        if (query == null) {
+            return 16;
+        }
+        try {
+            if (query.moveToFirst()) {
+                return query.getInt(query.getColumnIndex("status"));
+            }
+            return 16;
+        } finally {
+            query.close();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void deleteDownload(long j) {
+        this.mDownloadManager.remove(j);
+    }
+
+    public class DownloadReceiver extends BroadcastReceiver {
+        public DownloadReceiver() {
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            DownloadInfo downloadInfo;
+            boolean z;
+            if (TextUtils.equals(intent.getAction(), "android.intent.action.DOWNLOAD_COMPLETE")) {
+                long longExtra = intent.getLongExtra("extra_download_id", -1L);
+                if (longExtra >= 0 && (downloadInfo = (DownloadInfo) Downloader.this.mDownloadInfoMap.remove(Long.valueOf(longExtra))) != null) {
+                    if (Downloader.this.downloadStatus(longExtra) == 8) {
+                        z = Downloader.this.copyToDestination(downloadInfo);
+                        if (z) {
+                            Downloader.this.deleteDownload(longExtra);
+                        }
+                    } else {
+                        z = false;
+                    }
+                    Downloader.onDownloadComplete(z, downloadInfo);
+                }
+            }
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/network/GluTLS12SocketFactory.java

@@ -0,0 +1,108 @@
+package csdk.glucentralservices.network;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+/* loaded from: classes4.dex */
+public class GluTLS12SocketFactory extends SSLSocketFactory {
+    private final SSLSocketFactory delegate;
+    private static final Object contextLock = new Object();
+    private static final String[] SUPPORTED_PROTOCOLS = {"TLSv1.2"};
+    private static SSLContext sslContext = null;
+
+    @Nullable
+    public static GluTLS12SocketFactory createGluTLS12SocketFactory(@Nullable SSLContext sSLContext) {
+        return null;
+    }
+
+    public static void fixTLSPre21(@NonNull HttpsURLConnection httpsURLConnection, @Nullable GluTLS12SocketFactory gluTLS12SocketFactory) {
+    }
+
+    @Nullable
+    public static GluTLS12SocketFactory createGluTLS12SocketFactory() {
+        return createGluTLS12SocketFactory(null);
+    }
+
+    public static void fixTLSPre21(@NonNull HttpsURLConnection httpsURLConnection) {
+        fixTLSPre21(httpsURLConnection, createGluTLS12SocketFactory());
+    }
+
+    private GluTLS12SocketFactory(@Nullable SSLContext sSLContext) throws KeyManagementException, NoSuchAlgorithmException {
+        if (sSLContext != null) {
+            this.delegate = sSLContext.getSocketFactory();
+            return;
+        }
+        synchronized (contextLock) {
+            try {
+                if (sslContext == null) {
+                    SSLContext sSLContext2 = SSLContext.getInstance("TLS");
+                    sslContext = sSLContext2;
+                    sSLContext2.init(null, null, null);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        this.delegate = sslContext.getSocketFactory();
+    }
+
+    @Override // javax.net.ssl.SSLSocketFactory
+    public String[] getDefaultCipherSuites() {
+        return this.delegate.getDefaultCipherSuites();
+    }
+
+    @Override // javax.net.ssl.SSLSocketFactory
+    public String[] getSupportedCipherSuites() {
+        return this.delegate.getSupportedCipherSuites();
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket() throws IOException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket());
+    }
+
+    @Override // javax.net.ssl.SSLSocketFactory
+    public Socket createSocket(Socket socket, String str, int i, boolean z) throws IOException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(socket, str, i, z));
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket(String str, int i) throws IOException, UnknownHostException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(str, i));
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket(String str, int i, InetAddress inetAddress, int i2) throws IOException, UnknownHostException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(str, i, inetAddress, i2));
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket(InetAddress inetAddress, int i) throws IOException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(inetAddress, i));
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddress2, int i2) throws IOException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(inetAddress, i, inetAddress2, i2));
+    }
+
+    private Socket updateTLSProtocols(Socket socket) {
+        if (socket instanceof SSLSocket) {
+            try {
+                ((SSLSocket) socket).setEnabledProtocols(SUPPORTED_PROTOCOLS);
+            } catch (Exception unused) {
+            }
+        }
+        return socket;
+    }
+}

decompiled/sources/csdk/glucentralservices/network/NetworkResponse.java

@@ -0,0 +1,29 @@
+package csdk.glucentralservices.network;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class NetworkResponse {
+    public final byte[] body;
+    public final int code;
+    public final Exception exception;
+    public Map<String, String> responseHeaders;
+
+    public NetworkResponse(int i, byte[] bArr, Map<String, List<String>> map, Exception exc) {
+        this.code = i;
+        this.body = bArr;
+        this.exception = exc;
+        this.responseHeaders = null;
+        if (map != null) {
+            this.responseHeaders = new HashMap();
+            for (Map.Entry<String, List<String>> entry : map.entrySet()) {
+                String key = entry.getKey();
+                if (key != null && entry.getValue() != null && entry.getValue().size() > 0) {
+                    this.responseHeaders.put(key, entry.getValue().get(0));
+                }
+            }
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/network/NetworkUtils.java

@@ -0,0 +1,243 @@
+package csdk.glucentralservices.network;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.firebase.perf.network.FirebasePerfUrlConnection;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Collections;
+import java.util.Map;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLHandshakeException;
+import org.apache.http.client.methods.HttpPut;
+
+/* loaded from: classes4.dex */
+public class NetworkUtils {
+    private static final int REQUEST_TIME_OUT_MS = 3000;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r1v0 */
+    /* JADX WARN: Type inference failed for: r1v1 */
+    /* JADX WARN: Type inference failed for: r1v2, types: [java.io.Closeable] */
+    /* JADX WARN: Type inference failed for: r1v3 */
+    /* JADX WARN: Type inference failed for: r3v1 */
+    /* JADX WARN: Type inference failed for: r3v4, types: [java.net.HttpURLConnection] */
+    /* JADX WARN: Type inference failed for: r3v8 */
+    /* JADX WARN: Type inference failed for: r3v9 */
+    public static NetworkResponse sendRequest(String str, URL url, Map<String, String> map, String str2, long j) {
+        ?? r3;
+        HttpsURLConnection httpsURLConnection;
+        InputStream inputStream;
+        ?? r1 = 0;
+        r1 = 0;
+        try {
+            try {
+                httpsURLConnection = openConnection(str, url, map, str2, j);
+            } catch (Throwable th) {
+                th = th;
+                r1 = map;
+                r3 = str;
+            }
+            try {
+                int responseCode = httpsURLConnection.getResponseCode();
+                inputStream = responseCode >= 400 ? httpsURLConnection.getErrorStream() : httpsURLConnection.getInputStream();
+                try {
+                    NetworkResponse networkResponse = new NetworkResponse(responseCode, readAsByteArrayAndClose(inputStream), httpsURLConnection.getHeaderFields(), null);
+                    close(inputStream);
+                    httpsURLConnection.disconnect();
+                    return networkResponse;
+                } catch (SSLHandshakeException e) {
+                    e = e;
+                    PrintStream printStream = System.out;
+                    printStream.println("SSLHandshakeException occurred: " + e.getMessage());
+                    Throwable cause = e.getCause();
+                    if (cause != null) {
+                        printStream.println("Cause: " + cause.getMessage());
+                    }
+                    e.printStackTrace();
+                    NetworkResponse networkResponse2 = new NetworkResponse(-1, null, null, e);
+                    close(inputStream);
+                    if (httpsURLConnection != null) {
+                        httpsURLConnection.disconnect();
+                    }
+                    return networkResponse2;
+                } catch (Exception e2) {
+                    e = e2;
+                    System.out.println("Exception type: " + e.getClass());
+                    NetworkResponse networkResponse3 = new NetworkResponse(-1, null, null, e);
+                    close(inputStream);
+                    if (httpsURLConnection != null) {
+                        httpsURLConnection.disconnect();
+                    }
+                    return networkResponse3;
+                }
+            } catch (SSLHandshakeException e3) {
+                e = e3;
+                inputStream = null;
+            } catch (Exception e4) {
+                e = e4;
+                inputStream = null;
+            } catch (Throwable th2) {
+                th = th2;
+                r3 = httpsURLConnection;
+                close(r1);
+                if (r3 != 0) {
+                    r3.disconnect();
+                }
+                throw th;
+            }
+        } catch (SSLHandshakeException e5) {
+            e = e5;
+            httpsURLConnection = null;
+            inputStream = null;
+        } catch (Exception e6) {
+            e = e6;
+            httpsURLConnection = null;
+            inputStream = null;
+        } catch (Throwable th3) {
+            th = th3;
+            r3 = 0;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Not initialized variable reg: 10, insn: 0x002f: MOVE (r0 I:??[OBJECT, ARRAY]) = (r10 I:??[OBJECT, ARRAY]), block:B:35:0x002f */
+    /* JADX WARN: Type inference failed for: r7v0, types: [java.net.URL] */
+    /* JADX WARN: Type inference failed for: r7v1 */
+    /* JADX WARN: Type inference failed for: r7v2 */
+    /* JADX WARN: Type inference failed for: r7v3, types: [java.net.HttpURLConnection] */
+    /* JADX WARN: Type inference failed for: r7v4, types: [java.net.HttpURLConnection] */
+    /* JADX WARN: Type inference failed for: r7v5, types: [java.net.HttpURLConnection, java.net.URLConnection, javax.net.ssl.HttpsURLConnection] */
+    public static NetworkResponse downloadIntoFile(URL url, File file, long j) {
+        InputStream inputStream;
+        Closeable closeable;
+        Closeable closeable2 = null;
+        try {
+            try {
+                url = openConnection("GET", url, Collections.emptyMap(), null, j);
+            } catch (Throwable th) {
+                th = th;
+                closeable2 = closeable;
+            }
+            try {
+                int responseCode = url.getResponseCode();
+                if (responseCode >= 200 && responseCode < 300) {
+                    inputStream = url.getInputStream();
+                    try {
+                        copyIntoFile(inputStream, file);
+                        NetworkResponse networkResponse = new NetworkResponse(responseCode, null, null, null);
+                        close(inputStream);
+                        url.disconnect();
+                        return networkResponse;
+                    } catch (Exception e) {
+                        e = e;
+                        NetworkResponse networkResponse2 = new NetworkResponse(-1, null, null, e);
+                        close(inputStream);
+                        if (url != 0) {
+                            url.disconnect();
+                        }
+                        return networkResponse2;
+                    }
+                }
+                NetworkResponse networkResponse3 = new NetworkResponse(responseCode, null, null, null);
+                close(null);
+                url.disconnect();
+                return networkResponse3;
+            } catch (Exception e2) {
+                e = e2;
+                inputStream = null;
+            } catch (Throwable th2) {
+                th = th2;
+                close(closeable2);
+                if (url != 0) {
+                    url.disconnect();
+                }
+                throw th;
+            }
+        } catch (Exception e3) {
+            e = e3;
+            url = 0;
+            inputStream = null;
+        } catch (Throwable th3) {
+            th = th3;
+            url = 0;
+        }
+    }
+
+    public static void copyData(@NonNull InputStream inputStream, @NonNull OutputStream outputStream) throws IOException {
+        byte[] bArr = new byte[16384];
+        while (true) {
+            int read = inputStream.read(bArr);
+            if (read < 0) {
+                return;
+            } else {
+                outputStream.write(bArr, 0, read);
+            }
+        }
+    }
+
+    public static void copyIntoFile(@NonNull InputStream inputStream, @NonNull File file) throws IOException {
+        FileOutputStream fileOutputStream = new FileOutputStream(file);
+        try {
+            copyData(inputStream, fileOutputStream);
+        } finally {
+            fileOutputStream.close();
+        }
+    }
+
+    private static HttpsURLConnection openConnection(String str, URL url, Map<String, String> map, String str2, long j) throws IOException {
+        boolean z = TextUtils.equals(str, "POST") || TextUtils.equals(str, HttpPut.METHOD_NAME);
+        HttpsURLConnection httpsURLConnection = (HttpsURLConnection) ((URLConnection) FirebasePerfUrlConnection.instrument(url.openConnection()));
+        GluTLS12SocketFactory.fixTLSPre21(httpsURLConnection);
+        httpsURLConnection.setRequestMethod(str);
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            httpsURLConnection.setRequestProperty(entry.getKey(), entry.getValue());
+        }
+        httpsURLConnection.setAllowUserInteraction(false);
+        httpsURLConnection.setConnectTimeout(3000);
+        httpsURLConnection.setReadTimeout((int) j);
+        httpsURLConnection.setUseCaches(false);
+        if (z) {
+            httpsURLConnection.setDoOutput(true);
+            httpsURLConnection.connect();
+            OutputStream outputStream = httpsURLConnection.getOutputStream();
+            try {
+                outputStream.write(str2.getBytes("UTF-8"));
+            } finally {
+                outputStream.close();
+            }
+        } else {
+            httpsURLConnection.connect();
+        }
+        return httpsURLConnection;
+    }
+
+    private static byte[] readAsByteArrayAndClose(InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        try {
+            copyData(inputStream, byteArrayOutputStream);
+            return byteArrayOutputStream.toByteArray();
+        } finally {
+            byteArrayOutputStream.close();
+        }
+    }
+
+    private static void close(@Nullable Closeable closeable) {
+        if (closeable == null) {
+            return;
+        }
+        try {
+            closeable.close();
+        } catch (IOException unused) {
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/util/ActivityLifecycleCallbacks.java

@@ -0,0 +1,89 @@
+package csdk.glucentralservices.util;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.os.Bundle;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+public class ActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
+    public static final String APPLICATION_PAUSE = "onApplicationPaused";
+    public static final String APPLICATION_RESUME = "onApplicationResumed";
+    private Set<Activity> mActivities;
+    private Application mApplication;
+    private IAction2<String, Activity> mOnActivityCallback;
+
+    public boolean isRunning() {
+        return this.mApplication != null;
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityDestroyed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityResumed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+    }
+
+    public ActivityLifecycleCallbacks(Context context, IAction2<String, Activity> iAction2) {
+        Context applicationContext = context.getApplicationContext();
+        if (applicationContext instanceof Application) {
+            this.mOnActivityCallback = iAction2;
+            this.mActivities = new HashSet();
+            Application application = (Application) applicationContext;
+            this.mApplication = application;
+            application.registerActivityLifecycleCallbacks(this);
+        }
+    }
+
+    public void destroy() {
+        Common.runOnUIThread(new Runnable() { // from class: csdk.glucentralservices.util.ActivityLifecycleCallbacks.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (ActivityLifecycleCallbacks.this.mApplication != null) {
+                    ActivityLifecycleCallbacks.this.mApplication.unregisterActivityLifecycleCallbacks(this);
+                }
+                ActivityLifecycleCallbacks.this.mApplication = null;
+                ActivityLifecycleCallbacks.this.mOnActivityCallback = null;
+                ActivityLifecycleCallbacks.this.mActivities = null;
+            }
+        });
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStarted(Activity activity) {
+        if (this.mOnActivityCallback != null && addActivity(activity) && this.mActivities.size() == 1) {
+            this.mOnActivityCallback.apply("onApplicationResumed", activity);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(Activity activity) {
+        addActivity(activity);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(Activity activity) {
+        if (this.mOnActivityCallback != null && this.mActivities.remove(activity) && this.mActivities.size() == 0) {
+            this.mOnActivityCallback.apply("onApplicationPaused", activity);
+        }
+    }
+
+    private boolean addActivity(Activity activity) {
+        Set<Activity> set = this.mActivities;
+        if (set != null) {
+            return set.add(activity);
+        }
+        return false;
+    }
+}

decompiled/sources/csdk/glucentralservices/util/AndroidPlatform.java

@@ -0,0 +1,571 @@
+package csdk.glucentralservices.util;
+
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.graphics.Point;
+import android.net.Uri;
+import android.os.Build;
+import android.preference.PreferenceManager;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.internal.AnalyticsEvents;
+import com.google.android.gms.drive.DriveFile;
+import com.google.android.ump.ConsentForm;
+import com.google.android.ump.ConsentInformation;
+import com.google.android.ump.ConsentRequestParameters;
+import com.google.android.ump.FormError;
+import com.google.android.ump.UserMessagingPlatform;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.foundation.tools.SameMD5;
+import csdk.glucentralservices.consent.ConsentUI;
+import csdk.glucentralservices.consent.IConsentListener;
+import csdk.glucentralservices.devicetiers.DeviceTier;
+import csdk.glucentralservices.devicetiers.DeviceTiers;
+import csdk.glucentralservices.devicetiers.DeviceUtil;
+import csdk.glucentralservices.kvstore.StringStore;
+import csdk.glucentralservices.network.DownloadInfo;
+import csdk.glucentralservices.network.Downloader;
+import csdk.glucentralservices.network.NetworkResponse;
+import csdk.glucentralservices.network.NetworkUtils;
+import csdk.glucentralservices.webview.IWebViewListener;
+import csdk.glucentralservices.webview.WebView;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public class AndroidPlatform {
+    static boolean mCMPRegionDetected = false;
+    static boolean mCMPShouldShow = false;
+    private ActivityLifecycleCallbacks mActivityLifeCycleCallbacks;
+    private final Context mContext;
+    private boolean mIsAvailable = true;
+    private final Timer mTimer = new Timer("GluCentralServices-AndroidPlatform");
+    private Downloader mDownloader = null;
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void deleteConsentCallbacks(long j, long j2);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onApplicationEvent(String str);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onConsentEvent(long j, String str);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onDownloadResponse(long j, int i, String str);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onHTTPResponse(long j, int i, byte[] bArr, Map<String, String> map);
+
+    private native void onRequestCMPConsentInfoComplete(long j, boolean z);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onShowCMPConsentFormComplete(long j, boolean z, String str, String str2, String str3, String str4, String str5);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onShowConsentComplete(long j, String str);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onShowWebViewComplete(long j, String str, String str2);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public native void onTimerEvent(long j);
+
+    public String getLocale() {
+        return "";
+    }
+
+    public AndroidPlatform(Context context) {
+        this.mContext = context.getApplicationContext();
+    }
+
+    public void destroy() {
+        this.mIsAvailable = false;
+        Downloader downloader = this.mDownloader;
+        if (downloader != null) {
+            downloader.destroy();
+        }
+        this.mTimer.cancel();
+        ActivityLifecycleCallbacks activityLifecycleCallbacks = this.mActivityLifeCycleCallbacks;
+        if (activityLifecycleCallbacks != null) {
+            activityLifecycleCallbacks.destroy();
+        }
+    }
+
+    public void registerApplicationEvent() {
+        this.mActivityLifeCycleCallbacks = new ActivityLifecycleCallbacks(this.mContext, new IAction2<String, Activity>() { // from class: csdk.glucentralservices.util.AndroidPlatform.1
+            @Override // csdk.glucentralservices.util.IAction2
+            public void apply(String str, Activity activity) {
+                if (AndroidPlatform.this.mIsAvailable) {
+                    if ("onApplicationResumed".equals(str)) {
+                        AndroidPlatform.this.onApplicationEvent(CampaignEx.JSON_NATIVE_VIDEO_RESUME);
+                    } else if ("onApplicationPaused".equals(str)) {
+                        AndroidPlatform.this.onApplicationEvent(CampaignEx.JSON_NATIVE_VIDEO_PAUSE);
+                    }
+                }
+            }
+        });
+    }
+
+    public void sendHTTPRequest(String str, final String str2, String[] strArr, final String str3, final long j, final long j2) throws MalformedURLException {
+        final URL url = new URL(str);
+        final HashMap hashMap = new HashMap();
+        if (strArr != null) {
+            for (int i = 0; i < strArr.length; i += 2) {
+                hashMap.put(strArr[i], strArr[i + 1]);
+            }
+        }
+        runAsync(new Runnable() { // from class: csdk.glucentralservices.util.AndroidPlatform.2
+            @Override // java.lang.Runnable
+            public void run() {
+                NetworkResponse sendRequest = NetworkUtils.sendRequest(str2, url, hashMap, str3, j);
+                AndroidPlatform.this.onHTTPResponse(j2, sendRequest.code, sendRequest.body, sendRequest.responseHeaders);
+            }
+        });
+    }
+
+    public void downloadFile(String str, final String str2, final long j, final long j2, boolean z) throws MalformedURLException {
+        final URL url = new URL(str);
+        if (!z) {
+            runAsync(new Runnable() { // from class: csdk.glucentralservices.util.AndroidPlatform.3
+                @Override // java.lang.Runnable
+                public void run() {
+                    File file = new File(str2);
+                    String str3 = "";
+                    if (!file.getParentFile().exists() && !file.getParentFile().mkdirs()) {
+                        AndroidPlatform.this.onDownloadResponse(j2, 0, "");
+                        return;
+                    }
+                    int i = NetworkUtils.downloadIntoFile(url, new File(str2), j).code;
+                    if (i >= 200 && i < 300) {
+                        str3 = str2;
+                    }
+                    AndroidPlatform.this.onDownloadResponse(j2, i, str3);
+                }
+            });
+            return;
+        }
+        if (this.mDownloader == null) {
+            Downloader downloader = new Downloader(this.mContext);
+            this.mDownloader = downloader;
+            downloader.init();
+        }
+        this.mDownloader.download(str, str2, new Downloader.DownloadListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.4
+            @Override // csdk.glucentralservices.network.Downloader.DownloadListener
+            public void onDownloadComplete(boolean z2, DownloadInfo downloadInfo) {
+                int i;
+                String str3;
+                if (z2) {
+                    str3 = downloadInfo.destinationPath;
+                    i = 200;
+                } else {
+                    i = 0;
+                    str3 = "";
+                }
+                AndroidPlatform.this.onDownloadResponse(j2, i, str3);
+            }
+        });
+    }
+
+    public void scheduleEvent(long j, final long j2) {
+        this.mTimer.schedule(new TimerTask() { // from class: csdk.glucentralservices.util.AndroidPlatform.5
+            @Override // java.util.TimerTask, java.lang.Runnable
+            public void run() {
+                AndroidPlatform.this.onTimerEvent(j2);
+            }
+        }, j);
+    }
+
+    public String privateFilePath() {
+        return this.mContext.getFilesDir().toString();
+    }
+
+    public boolean checkPrivateDirectoryExists(String str, boolean z) {
+        File file = new File(str);
+        return !file.exists() && z && file.mkdirs();
+    }
+
+    public boolean removePrivateData(String str) {
+        File file = new File(str);
+        if (file.isDirectory() && file.list().length > 0) {
+            for (String str2 : file.list()) {
+            }
+        }
+        return false;
+    }
+
+    public String getApplicationVersion() {
+        try {
+            return this.mContext.getPackageManager().getPackageInfo(this.mContext.getPackageName(), 0).versionName;
+        } catch (PackageManager.NameNotFoundException unused) {
+            return "";
+        }
+    }
+
+    public String getApplicationID() {
+        return this.mContext.getPackageName();
+    }
+
+    public String[] readProperties(String str, String[] strArr) {
+        SharedPreferences sharedPreferences = this.mContext.getSharedPreferences(str, 0);
+        ArrayList arrayList = new ArrayList(strArr.length * 2);
+        for (String str2 : strArr) {
+            String string = sharedPreferences.getString(str2, null);
+            if (string != null) {
+                arrayList.add(str2);
+                arrayList.add(string);
+            }
+        }
+        return (String[]) arrayList.toArray(new String[arrayList.size()]);
+    }
+
+    public void writeProperties(String str, String[] strArr) {
+        SharedPreferences.Editor edit = this.mContext.getSharedPreferences(str, 0).edit();
+        for (int i = 0; i < strArr.length; i += 2) {
+            try {
+                edit.putString(strArr[i], strArr[i + 1]);
+            } finally {
+                edit.apply();
+            }
+        }
+    }
+
+    public String readSharedProperty(String str) {
+        SharedPreferences sharedPreferences = this.mContext.getSharedPreferences("glu-analytics", 0);
+        if (!sharedPreferences.contains(str)) {
+            return "";
+        }
+        try {
+            return sharedPreferences.getBoolean(str, false) ? "true" : "false";
+        } catch (ClassCastException unused) {
+            return "";
+        }
+    }
+
+    public void md5(ByteBuffer byteBuffer, ByteBuffer byteBuffer2) throws NoSuchAlgorithmException {
+        byte[] bArr = new byte[1024];
+        MessageDigest messageDigest = MessageDigest.getInstance(SameMD5.TAG);
+        while (byteBuffer.remaining() > 0) {
+            int min = Math.min(1024, byteBuffer.remaining());
+            byteBuffer.get(bArr, 0, min);
+            messageDigest.update(bArr, 0, min);
+        }
+        byteBuffer2.put(messageDigest.digest());
+    }
+
+    public int getDeviceTier() {
+        DeviceTier deviceTier = DeviceTiers.getDeviceTier(this.mContext);
+        return (deviceTier.fallback ? 256 : 0) | deviceTier.tier;
+    }
+
+    public int getCpuCoreCount() {
+        return DeviceUtil.getCpuCount();
+    }
+
+    public String getGpuDeviceVendor() {
+        DeviceUtil.GlesData glesData = DeviceUtil.getGlesData();
+        return glesData != null ? glesData.gpuVendor : AnalyticsEvents.PARAMETER_DIALOG_OUTCOME_VALUE_UNKNOWN;
+    }
+
+    public String getGpuDeviceName() {
+        DeviceUtil.GlesData glesData = DeviceUtil.getGlesData();
+        return glesData != null ? glesData.gpuRenderer : AnalyticsEvents.PARAMETER_DIALOG_OUTCOME_VALUE_UNKNOWN;
+    }
+
+    public double getRamAmount() {
+        try {
+            ((ActivityManager) this.mContext.getSystemService("activity")).getMemoryInfo(new ActivityManager.MemoryInfo());
+            return (r0.totalMem / 1024.0d) / 1024.0d;
+        } catch (Exception unused) {
+            return 0.0d;
+        }
+    }
+
+    public String getCpuName() {
+        return Build.SUPPORTED_ABIS[0];
+    }
+
+    public String getScreenSize() {
+        Point screenSize = DeviceUtil.getScreenSize(this.mContext);
+        return Math.min(screenSize.x, screenSize.y) + "x" + Math.max(screenSize.x, screenSize.y);
+    }
+
+    public String getETC2IfSupported() {
+        DeviceUtil.GlesData glesData = DeviceUtil.getGlesData();
+        return glesData != null ? glesData.supportedTextureFormat : "";
+    }
+
+    public String getLanguage() {
+        Locale locale = Locale.getDefault();
+        if (locale.getCountry().equalsIgnoreCase("tw") || locale.getCountry().equalsIgnoreCase("hk")) {
+            return locale.getLanguage() + "-hant";
+        }
+        if (locale.getLanguage().equalsIgnoreCase("es") || locale.getLanguage().equalsIgnoreCase("pt")) {
+            return locale.getLanguage() + "-" + locale.getCountry();
+        }
+        return locale.getLanguage();
+    }
+
+    public void showConsent(final long j, final long j2, final Activity activity, final String str) {
+        if (activity == null) {
+            throw new IllegalArgumentException("activity can't be null");
+        }
+        Common.runOnUIThread(new Runnable() { // from class: csdk.glucentralservices.util.AndroidPlatform.6
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    new ConsentUI(activity).showConsent(str, new IConsentListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.6.1
+                        @Override // csdk.glucentralservices.consent.IConsentListener
+                        public void onConsentStatusReceived(String str2, Throwable th) {
+                            if (th != null) {
+                                AnonymousClass6 anonymousClass6 = AnonymousClass6.this;
+                                AndroidPlatform.this.onShowConsentComplete(j, th.getMessage());
+                            } else {
+                                AnonymousClass6 anonymousClass62 = AnonymousClass6.this;
+                                AndroidPlatform.this.onShowConsentComplete(j, str2);
+                            }
+                            AnonymousClass6 anonymousClass63 = AnonymousClass6.this;
+                            AndroidPlatform.this.deleteConsentCallbacks(j, j2);
+                        }
+
+                        @Override // csdk.glucentralservices.consent.IConsentListener
+                        public void onConsentEventReceived(String str2) {
+                            AnonymousClass6 anonymousClass6 = AnonymousClass6.this;
+                            AndroidPlatform.this.onConsentEvent(j2, str2);
+                        }
+                    });
+                } catch (Exception e) {
+                    AndroidPlatform.this.onShowConsentComplete(j, e.getMessage());
+                    AndroidPlatform.this.deleteConsentCallbacks(j, j2);
+                }
+            }
+        });
+    }
+
+    public void showWebView(final long j, final Activity activity, final String str, final String str2) {
+        if (activity == null) {
+            throw new IllegalArgumentException("activity can't be null");
+        }
+        Common.runOnUIThread(new Runnable() { // from class: csdk.glucentralservices.util.AndroidPlatform.7
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    new WebView(activity).show(str, str2, new IWebViewListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.7.1
+                        @Override // csdk.glucentralservices.webview.IWebViewListener
+                        public void onStatusReceived(String str3, Throwable th) {
+                            AnonymousClass7 anonymousClass7 = AnonymousClass7.this;
+                            AndroidPlatform.this.onShowWebViewComplete(j, str3, th != null ? th.getMessage() : null);
+                        }
+                    });
+                } catch (Exception e) {
+                    AndroidPlatform.this.onShowWebViewComplete(j, null, e.getMessage());
+                }
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void processCMPConsentResult(long j, @Nullable FormError formError) {
+        boolean z = UserMessagingPlatform.getConsentInformation(this.mContext).getPrivacyOptionsRequirementStatus() == ConsentInformation.PrivacyOptionsRequirementStatus.REQUIRED;
+        if (formError != null) {
+            onShowCMPConsentFormComplete(j, z, null, null, null, null, String.format("%s: %s", Integer.valueOf(formError.getErrorCode()), formError.getMessage()));
+        } else {
+            SharedPreferences defaultSharedPreferences = PreferenceManager.getDefaultSharedPreferences(this.mContext);
+            onShowCMPConsentFormComplete(j, z, defaultSharedPreferences.getString("IABTCF_PurposeConsents", ""), defaultSharedPreferences.getString("IABTCF_PurposeLegitimateInterests", ""), defaultSharedPreferences.getString("IABTCF_VendorConsents", ""), defaultSharedPreferences.getString("IABTCF_AddtlConsent", ""), null);
+        }
+    }
+
+    /* renamed from: csdk.glucentralservices.util.AndroidPlatform$8, reason: invalid class name */
+    public class AnonymousClass8 implements Runnable {
+        final /* synthetic */ Activity val$activity;
+        final /* synthetic */ long val$nativeCallback;
+        final /* synthetic */ boolean val$showSettings;
+        final /* synthetic */ boolean val$underAge;
+
+        public AnonymousClass8(boolean z, Activity activity, long j, boolean z2) {
+            this.val$showSettings = z;
+            this.val$activity = activity;
+            this.val$nativeCallback = j;
+            this.val$underAge = z2;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            try {
+                if (this.val$showSettings) {
+                    UserMessagingPlatform.showPrivacyOptionsForm(this.val$activity, new ConsentForm.OnConsentFormDismissedListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.8.1
+                        @Override // com.google.android.ump.ConsentForm.OnConsentFormDismissedListener
+                        public void onConsentFormDismissed(@Nullable FormError formError) {
+                            AnonymousClass8 anonymousClass8 = AnonymousClass8.this;
+                            AndroidPlatform.this.processCMPConsentResult(anonymousClass8.val$nativeCallback, formError);
+                        }
+                    });
+                } else if (AndroidPlatform.mCMPShouldShow && !this.val$underAge) {
+                    UserMessagingPlatform.loadAndShowConsentFormIfRequired(this.val$activity, new ConsentForm.OnConsentFormDismissedListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.8.2
+                        @Override // com.google.android.ump.ConsentForm.OnConsentFormDismissedListener
+                        public void onConsentFormDismissed(@Nullable FormError formError) {
+                            AnonymousClass8 anonymousClass8 = AnonymousClass8.this;
+                            AndroidPlatform.this.processCMPConsentResult(anonymousClass8.val$nativeCallback, formError);
+                        }
+                    });
+                } else {
+                    UserMessagingPlatform.getConsentInformation(AndroidPlatform.this.mContext).requestConsentInfoUpdate(this.val$activity, new ConsentRequestParameters.Builder().setTagForUnderAgeOfConsent(this.val$underAge).build(), new ConsentInformation.OnConsentInfoUpdateSuccessListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.8.3
+                        @Override // com.google.android.ump.ConsentInformation.OnConsentInfoUpdateSuccessListener
+                        public void onConsentInfoUpdateSuccess() {
+                            UserMessagingPlatform.loadAndShowConsentFormIfRequired(AnonymousClass8.this.val$activity, new ConsentForm.OnConsentFormDismissedListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.8.3.1
+                                @Override // com.google.android.ump.ConsentForm.OnConsentFormDismissedListener
+                                public void onConsentFormDismissed(@Nullable FormError formError) {
+                                    AnonymousClass8 anonymousClass8 = AnonymousClass8.this;
+                                    AndroidPlatform.this.processCMPConsentResult(anonymousClass8.val$nativeCallback, formError);
+                                }
+                            });
+                        }
+                    }, new ConsentInformation.OnConsentInfoUpdateFailureListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.8.4
+                        @Override // com.google.android.ump.ConsentInformation.OnConsentInfoUpdateFailureListener
+                        public void onConsentInfoUpdateFailure(@NonNull FormError formError) {
+                            AnonymousClass8 anonymousClass8 = AnonymousClass8.this;
+                            AndroidPlatform.this.processCMPConsentResult(anonymousClass8.val$nativeCallback, formError);
+                        }
+                    });
+                }
+            } catch (Exception e) {
+                AndroidPlatform.this.onShowCMPConsentFormComplete(this.val$nativeCallback, false, null, null, null, null, e.getMessage());
+            }
+        }
+    }
+
+    public void showCMPConsentForm(long j, Activity activity, boolean z, boolean z2) {
+        if (activity == null) {
+            throw new IllegalArgumentException("activity can't be null");
+        }
+        Common.runOnUIThread(new AnonymousClass8(z, activity, j, z2));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onCMPRegionDetected(long j, boolean z) {
+        mCMPShouldShow = z;
+        mCMPRegionDetected = true;
+        onRequestCMPConsentInfoComplete(j, z);
+    }
+
+    public void requestCMPConsentInfo(final long j, final Activity activity) {
+        if (activity == null) {
+            throw new IllegalArgumentException("activity can't be null");
+        }
+        if (mCMPRegionDetected) {
+            onRequestCMPConsentInfoComplete(j, mCMPShouldShow);
+        } else {
+            Common.runOnUIThread(new Runnable() { // from class: csdk.glucentralservices.util.AndroidPlatform.9
+                @Override // java.lang.Runnable
+                public void run() {
+                    try {
+                        ConsentRequestParameters build = new ConsentRequestParameters.Builder().setTagForUnderAgeOfConsent(false).build();
+                        final ConsentInformation consentInformation = UserMessagingPlatform.getConsentInformation(AndroidPlatform.this.mContext);
+                        consentInformation.requestConsentInfoUpdate(activity, build, new ConsentInformation.OnConsentInfoUpdateSuccessListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.9.1
+                            @Override // com.google.android.ump.ConsentInformation.OnConsentInfoUpdateSuccessListener
+                            public void onConsentInfoUpdateSuccess() {
+                                boolean z = consentInformation.getConsentStatus() != 1;
+                                AnonymousClass9 anonymousClass9 = AnonymousClass9.this;
+                                AndroidPlatform.this.onCMPRegionDetected(j, z);
+                            }
+                        }, new ConsentInformation.OnConsentInfoUpdateFailureListener() { // from class: csdk.glucentralservices.util.AndroidPlatform.9.2
+                            @Override // com.google.android.ump.ConsentInformation.OnConsentInfoUpdateFailureListener
+                            public void onConsentInfoUpdateFailure(@NonNull FormError formError) {
+                                AnonymousClass9 anonymousClass9 = AnonymousClass9.this;
+                                AndroidPlatform.this.onCMPRegionDetected(j, false);
+                            }
+                        });
+                    } catch (Exception unused) {
+                        AndroidPlatform.this.onCMPRegionDetected(j, false);
+                    }
+                }
+            });
+        }
+    }
+
+    public void openURL(final String str) {
+        Common.runOnUIThread(new Runnable() { // from class: csdk.glucentralservices.util.AndroidPlatform.10
+            @Override // java.lang.Runnable
+            public void run() {
+                Intent data = new Intent().setAction("android.intent.action.VIEW").setData(Uri.parse(str));
+                data.setFlags(DriveFile.MODE_READ_ONLY);
+                AndroidPlatform.this.mContext.startActivity(data);
+            }
+        });
+    }
+
+    public void presentToast(final String str) {
+        Common.runOnUIThread(new Runnable() { // from class: csdk.glucentralservices.util.AndroidPlatform.11
+            @Override // java.lang.Runnable
+            public void run() {
+                Toast.makeText(AndroidPlatform.this.mContext, str, 1).show();
+            }
+        });
+    }
+
+    public boolean isNewInstall() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(privateFilePath());
+        sb.append("/tags");
+        return !new File(sb.toString()).exists();
+    }
+
+    public String readAssetAsString(String str) throws IOException {
+        try {
+            InputStream open = this.mContext.getAssets().open(str);
+            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(open));
+            try {
+                StringBuilder sb = new StringBuilder(open.available());
+                char[] cArr = new char[16384];
+                while (true) {
+                    int read = bufferedReader.read(cArr);
+                    if (read >= 0) {
+                        sb.append(cArr, 0, read);
+                    } else {
+                        return sb.toString();
+                    }
+                }
+            } finally {
+                bufferedReader.close();
+            }
+        } catch (Exception unused) {
+            return null;
+        }
+    }
+
+    public String getFromStringStore(String str) {
+        return StringStore.get(str);
+    }
+
+    public void setToStringStore(String str, String str2) {
+        StringStore.set(str, str2);
+    }
+
+    public String generateUUID() {
+        return UUID.randomUUID().toString();
+    }
+
+    private void runAsync(Runnable runnable) {
+        new Thread(runnable).start();
+    }
+}

decompiled/sources/csdk/glucentralservices/util/Common.java

@@ -0,0 +1,42 @@
+package csdk.glucentralservices.util;
+
+import android.os.Handler;
+import android.os.Looper;
+
+/* loaded from: classes4.dex */
+public class Common {
+    private static Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public static void require(boolean z) {
+        if (!z) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void require(boolean z, String str) {
+        if (z) {
+            return;
+        }
+        if (str != null) {
+            throw new IllegalArgumentException(str);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public static RuntimeException propagate(Throwable th) {
+        if (th instanceof Error) {
+            throw ((Error) th);
+        }
+        if (th instanceof RuntimeException) {
+            throw ((RuntimeException) th);
+        }
+        throw new RuntimeException(th);
+    }
+
+    public static void runOnUIThread(Runnable runnable) {
+        require(runnable != null, "runnable == null");
+        if (!mainHandler.post(runnable)) {
+            throw new IllegalStateException("Failed to post runnable");
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/util/IAction2.java

@@ -0,0 +1,6 @@
+package csdk.glucentralservices.util;
+
+/* loaded from: classes4.dex */
+public interface IAction2<T1, T2> {
+    void apply(T1 t1, T2 t2);
+}

decompiled/sources/csdk/glucentralservices/webview/IWebViewListener.java

@@ -0,0 +1,6 @@
+package csdk.glucentralservices.webview;
+
+/* loaded from: classes4.dex */
+public interface IWebViewListener {
+    void onStatusReceived(String str, Throwable th);
+}

decompiled/sources/csdk/glucentralservices/webview/NullWebViewListener.java

@@ -0,0 +1,10 @@
+package csdk.glucentralservices.webview;
+
+/* loaded from: classes4.dex */
+public class NullWebViewListener implements IWebViewListener {
+    public static final IWebViewListener INSTANCE = new NullWebViewListener();
+
+    @Override // csdk.glucentralservices.webview.IWebViewListener
+    public void onStatusReceived(String str, Throwable th) {
+    }
+}

decompiled/sources/csdk/glucentralservices/webview/WebView.java

@@ -0,0 +1,194 @@
+package csdk.glucentralservices.webview;
+
+import android.R;
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.graphics.drawable.ColorDrawable;
+import android.text.TextUtils;
+import android.webkit.WebResourceError;
+import android.webkit.WebResourceRequest;
+import androidx.annotation.RequiresApi;
+import com.google.firebase.perf.network.FirebasePerfUrlConnection;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.concurrent.atomic.AtomicReference;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class WebView {
+    private final Activity mActivity;
+    private JSONObject mConfig;
+    private Dialog mDialog;
+    private AtomicReference<IWebViewListener> mListener = new AtomicReference<>(NullWebViewListener.INSTANCE);
+    private android.webkit.WebView mWebView;
+
+    public class WebViewClient extends android.webkit.WebViewClient {
+        private WebViewClient() {
+        }
+
+        @Override // android.webkit.WebViewClient
+        public void onLoadResource(android.webkit.WebView webView, String str) {
+            super.onLoadResource(webView, str);
+        }
+
+        @Override // android.webkit.WebViewClient
+        @RequiresApi(api = 24)
+        public boolean shouldOverrideUrlLoading(android.webkit.WebView webView, WebResourceRequest webResourceRequest) {
+            return shouldOverrideUrlLoading(webView, webResourceRequest.getUrl().toString());
+        }
+
+        @Override // android.webkit.WebViewClient
+        public boolean shouldOverrideUrlLoading(android.webkit.WebView webView, String str) {
+            String optString = WebView.this.mConfig.optString("scheme", "");
+            if (optString.length() <= 0 || !str.startsWith(optString)) {
+                return false;
+            }
+            WebView.this.onDismissed(str);
+            return true;
+        }
+
+        @Override // android.webkit.WebViewClient
+        public void onPageFinished(android.webkit.WebView webView, String str) {
+            super.onPageFinished(webView, str);
+            WebView.this.onLoaded(null);
+        }
+
+        @Override // android.webkit.WebViewClient
+        @RequiresApi(api = 23)
+        public void onReceivedError(android.webkit.WebView webView, WebResourceRequest webResourceRequest, WebResourceError webResourceError) {
+            onReceivedError(webView, webResourceError.getErrorCode(), webResourceError.getDescription().toString(), webResourceRequest.getUrl().toString());
+        }
+
+        @Override // android.webkit.WebViewClient
+        public void onReceivedError(android.webkit.WebView webView, int i, String str, String str2) {
+            String optString = WebView.this.mConfig.optString("largeFileFilter", "");
+            if (optString == null || optString.length() == 0 || !str2.contains(optString)) {
+                System.out.println("WebViewClient::onReceivedError: " + str2);
+                WebView.this.onLoaded(new Exception(str));
+            }
+        }
+    }
+
+    public WebView(Activity activity) {
+        this.mActivity = activity;
+    }
+
+    public void show(String str, String str2, IWebViewListener iWebViewListener) {
+        AtomicReference<IWebViewListener> atomicReference = this.mListener;
+        if (iWebViewListener == null) {
+            iWebViewListener = NullWebViewListener.INSTANCE;
+        }
+        atomicReference.set(iWebViewListener);
+        showDialog();
+        load(str, str2);
+    }
+
+    private void load(String str, String str2) {
+        InputStream openStream;
+        try {
+            this.mConfig = new JSONObject(str2);
+            if (TextUtils.isEmpty(str)) {
+                onLoaded(new Exception("url is not set"));
+                return;
+            }
+            if (str.startsWith("http")) {
+                this.mWebView.loadUrl(str);
+                return;
+            }
+            InputStream inputStream = null;
+            try {
+                if (str.startsWith("file:///android_asset")) {
+                    openStream = this.mActivity.getAssets().open(str.substring(str.lastIndexOf("/") + 1));
+                } else {
+                    openStream = FirebasePerfUrlConnection.openStream(new URL(str));
+                }
+                inputStream = openStream;
+                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+                byte[] bArr = new byte[1024];
+                while (true) {
+                    int read = inputStream.read(bArr);
+                    if (read != -1) {
+                        byteArrayOutputStream.write(bArr, 0, read);
+                    } else {
+                        String byteArrayOutputStream2 = byteArrayOutputStream.toString("UTF-8");
+                        inputStream.close();
+                        this.mWebView.loadDataWithBaseURL("", byteArrayOutputStream2, "text/html", "UTF-8", null);
+                        return;
+                    }
+                }
+            } catch (Throwable th) {
+                inputStream.close();
+                throw th;
+            }
+        } catch (Exception e) {
+            onLoaded(e);
+        }
+    }
+
+    private void showDialog() {
+        createWebView();
+        Dialog dialog = new Dialog(this.mActivity, R.style.Theme.Translucent.NoTitleBar);
+        this.mDialog = dialog;
+        dialog.setContentView(this.mWebView);
+        this.mDialog.setCancelable(true);
+        this.mDialog.getWindow().setLayout(-1, -1);
+        this.mDialog.getWindow().setFlags(8, 8);
+        this.mDialog.getWindow().getDecorView().setSystemUiVisibility(4870);
+        this.mDialog.getWindow().setBackgroundDrawable(new ColorDrawable(0));
+        this.mDialog.setOnShowListener(new DialogInterface.OnShowListener() { // from class: csdk.glucentralservices.webview.WebView.1
+            @Override // android.content.DialogInterface.OnShowListener
+            public void onShow(DialogInterface dialogInterface) {
+            }
+        });
+        this.mDialog.setOnCancelListener(new DialogInterface.OnCancelListener() { // from class: csdk.glucentralservices.webview.WebView.2
+            @Override // android.content.DialogInterface.OnCancelListener
+            public void onCancel(DialogInterface dialogInterface) {
+                WebView.this.onStatusReceived("gluact:dismiss", null);
+            }
+        });
+        this.mDialog.show();
+        if (!this.mDialog.isShowing()) {
+            onLoaded(new Exception("Dialog of WebView could not be displayed."));
+        }
+        this.mDialog.getWindow().clearFlags(8);
+    }
+
+    private void createWebView() {
+        android.webkit.WebView webView = new android.webkit.WebView(this.mActivity);
+        this.mWebView = webView;
+        webView.setBackgroundColor(0);
+        this.mWebView.getSettings().setJavaScriptEnabled(true);
+        this.mWebView.setWebViewClient(new WebViewClient());
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onDismissed(String str) {
+        this.mDialog.dismiss();
+        onStatusReceived(str, null);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onLoaded(Throwable th) {
+        if (th == null) {
+            runScript();
+        } else {
+            onStatusReceived(null, th);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onStatusReceived(String str, Throwable th) {
+        this.mListener.get().onStatusReceived(str, th);
+        this.mListener.set(NullWebViewListener.INSTANCE);
+    }
+
+    private void runScript() {
+        String optString = this.mConfig.optString("script", "");
+        if (optString == null || optString.length() == 0) {
+            return;
+        }
+        this.mWebView.evaluateJavascript(String.format("setTimeout(function(){%s;}, 1);", optString), null);
+    }
+}