Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/csdk/gluads/util/AdvertisingUtil.java

@@ -0,0 +1,44 @@
+package csdk.gluads.util;
+
+import android.content.Context;
+import android.content.Intent;
+import androidx.annotation.NonNull;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+import csdk.gluads.Consts;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import csdk.gluads.impl.AdvertisingImpl;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class AdvertisingUtil {
+    public static boolean isAPIEnabled() {
+        return true;
+    }
+
+    public static void broadcastNetworkIntent(@NonNull Context context, String str) {
+        LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent(str));
+    }
+
+    public static void updatePrivacyInfoAndBroadcast(@NonNull Context context, String str, @NonNull String str2, IAction1<PrivacyStatus> iAction1, @NonNull AdvertisingImpl advertisingImpl) {
+        advertisingImpl.setAdvertisingPrivacyStage(str, str2, iAction1);
+        broadcastNetworkIntent(context, Consts.SDK_PRIVACY_STAGE_PREFIX + str2 + Consts.STRING_PERIOD + str);
+    }
+
+    public static void broadcastAdMarkup(@NonNull Context context, String str, String str2, String str3) {
+        LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(context);
+        Intent intent = new Intent(str);
+        intent.putExtra("adUnitID", str2);
+        intent.putExtra("adMarkup", str3);
+        localBroadcastManager.sendBroadcast(intent);
+    }
+
+    public static String findPlacementNameForReward(@NonNull Map<String, Reward> map, @NonNull String str, int i) {
+        for (Map.Entry<String, Reward> entry : map.entrySet()) {
+            if (entry.getValue().item.equals(str) && entry.getValue().amount == i) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+}

decompiled-community/sources/csdk/gluads/util/Common.java

@@ -0,0 +1,186 @@
+package csdk.gluads.util;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Handler;
+import android.os.Looper;
+import android.provider.Settings;
+import android.util.Base64;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.ads.identifier.AdvertisingIdClient;
+import com.mbridge.msdk.foundation.tools.SameMD5;
+import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes4.dex */
+public class Common {
+    private static Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public static <T> T or(T t, T t2) {
+        return t != null ? t : t2;
+    }
+
+    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 String emptyToNull(String str) {
+        if (str == null || str.length() > 0) {
+            return str;
+        }
+        return null;
+    }
+
+    public static <T> T call(Callable<T> callable) {
+        try {
+            return callable.call();
+        } catch (Exception e) {
+            throw propagate(e);
+        }
+    }
+
+    public static String uuid() {
+        return UUID.randomUUID().toString();
+    }
+
+    public static <K, V> Map<K, V> createMap() {
+        return new HashMap();
+    }
+
+    public static <K, V> Map<K, V> shallowClone(Map<K, V> map) {
+        if (map == null) {
+            return null;
+        }
+        Map<K, V> createMap = createMap();
+        createMap.putAll(map);
+        return createMap;
+    }
+
+    public static <K, V> V get(Map<K, V> map, K k, V v) {
+        if (map == null || k == null) {
+            return v;
+        }
+        V v2 = map.get(k);
+        return (v2 != null || map.containsKey(k)) ? v2 : v;
+    }
+
+    public static <K, V> V get(Map<K, V> map, K k) {
+        return (V) get(map, k, null);
+    }
+
+    public static boolean isEmpty(Map<?, ?> map) {
+        return map == null || map.isEmpty();
+    }
+
+    public static void runOnUIThread(Runnable runnable) {
+        require(runnable != null, "runnable == null");
+        if (!mainHandler.post(runnable)) {
+            throw new IllegalStateException("Failed to post runnable");
+        }
+    }
+
+    public static void runOnUIThreadDelayed(Runnable runnable, long j) {
+        require(runnable != null, "runnable == null");
+        if (!mainHandler.postDelayed(runnable, j)) {
+            throw new IllegalStateException("Failed to post runnable");
+        }
+    }
+
+    public static long msTimestamp() {
+        return System.nanoTime() / 1000000;
+    }
+
+    public static String getGAID(Context context) {
+        try {
+            return AdvertisingIdClient.getAdvertisingIdInfo(context).getId();
+        } catch (Exception unused) {
+            return "";
+        }
+    }
+
+    public static String getAdMobTestDeviceID(Context context) {
+        return md5(Settings.Secure.getString(context.getContentResolver(), "android_id")).toUpperCase(Locale.US);
+    }
+
+    public static Map<String, Object> getMapFromUserID(String str) {
+        try {
+            return JsonUtil.parseJsonObject(new String(Base64.decode(str, 0), "UTF-8"));
+        } catch (Exception unused) {
+            return createMap();
+        }
+    }
+
+    public static String getUserIDFromMap(Map<String, Object> map) {
+        return Base64.encodeToString(JsonUtil.toJson(map).getBytes(Charset.forName("UTF-8")), 10).trim();
+    }
+
+    public static String removeRevIDAndSessionIDFromUserID(String str) {
+        Map<String, Object> mapFromUserID = getMapFromUserID(str);
+        mapFromUserID.remove("revId");
+        mapFromUserID.remove("sessionId");
+        return getUserIDFromMap(mapFromUserID);
+    }
+
+    private static String md5(String str) {
+        try {
+            return String.format("%032X", new BigInteger(1, MessageDigest.getInstance(SameMD5.TAG).digest(str.getBytes())));
+        } catch (NoSuchAlgorithmException unused) {
+            return "";
+        }
+    }
+
+    public static Map<String, Object> loadMap(SharedPreferences sharedPreferences, String str) {
+        try {
+            return JsonUtil.parseJsonObject(sharedPreferences.getString(str, ""));
+        } catch (Exception unused) {
+            return new HashMap();
+        }
+    }
+
+    public static void saveMap(SharedPreferences sharedPreferences, String str, Map<String, Object> map) {
+        SharedPreferences.Editor edit = sharedPreferences.edit();
+        edit.putString(str, JsonUtil.toJson(map));
+        edit.apply();
+    }
+
+    @NonNull
+    public static Map<String, String> mapSSFromConfig(@Nullable Map<String, Object> map) {
+        Map<String, String> createMap = createMap();
+        if (map != null) {
+            for (Map.Entry<String, Object> entry : map.entrySet()) {
+                createMap.put(entry.getKey(), (String) entry.getValue());
+            }
+        }
+        return createMap;
+    }
+}

decompiled-community/sources/csdk/gluads/util/ConfigUtil.java

@@ -0,0 +1,220 @@
+package csdk.gluads.util;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.Consts;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class ConfigUtil {
+    public static boolean getBoolean(@Nullable Object obj, @NonNull String str) {
+        return getBoolean(obj, str, false);
+    }
+
+    public static boolean getBoolean(@Nullable Object obj, @NonNull String str, boolean z) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return z;
+        }
+        if (object instanceof Boolean) {
+            return ((Boolean) object).booleanValue();
+        }
+        if (object instanceof String) {
+            String str2 = (String) object;
+            if (TextUtils.equals(str2, "true")) {
+                return true;
+            }
+            if (TextUtils.equals(str2, "false")) {
+                return false;
+            }
+            throw new IllegalArgumentException("Can't convert string to boolean value: " + str2 + Consts.STRING_PERIOD);
+        }
+        throw new IllegalArgumentException("Unsupported type for boolean value: " + object.getClass());
+    }
+
+    public static int getInteger(@Nullable Object obj, @NonNull String str) {
+        return getInteger(obj, str, 0);
+    }
+
+    public static int getInteger(@Nullable Object obj, @NonNull String str, int i) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return i;
+        }
+        if (object instanceof Number) {
+            return ((Number) object).intValue();
+        }
+        if (object instanceof String) {
+            return Integer.parseInt((String) object);
+        }
+        throw new IllegalArgumentException("Unsupported type for int value: " + object.getClass());
+    }
+
+    public static Integer getInteger(@Nullable Object obj, @NonNull String str, Integer num) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return num;
+        }
+        if (object instanceof Number) {
+            return Integer.valueOf(((Number) object).intValue());
+        }
+        if (object instanceof String) {
+            return Integer.valueOf(Integer.parseInt((String) object));
+        }
+        throw new IllegalArgumentException("Unsupported type for int value: " + object.getClass());
+    }
+
+    public static long getLong(@Nullable Object obj, @NonNull String str) {
+        return getLong(obj, str, 0L);
+    }
+
+    public static long getLong(@Nullable Object obj, @NonNull String str, long j) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return j;
+        }
+        if (object instanceof Number) {
+            return ((Number) object).longValue();
+        }
+        if (object instanceof String) {
+            return Long.parseLong((String) object);
+        }
+        throw new IllegalArgumentException("Unsupported type for long value: " + object.getClass());
+    }
+
+    public static double getDouble(@Nullable Object obj, @NonNull String str) {
+        return getDouble(obj, str, 0.0d);
+    }
+
+    public static double getDouble(@Nullable Object obj, @NonNull String str, double d) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return d;
+        }
+        if (object instanceof Number) {
+            return ((Number) object).doubleValue();
+        }
+        if (object instanceof String) {
+            return Double.parseDouble((String) object);
+        }
+        throw new IllegalArgumentException("Unsupported type for double value: " + object.getClass());
+    }
+
+    @Nullable
+    public static String getString(@Nullable Object obj, @NonNull String str) {
+        return getString(obj, str, null);
+    }
+
+    @Nullable
+    public static String getString(@Nullable Object obj, @NonNull String str, @Nullable String str2) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return str2;
+        }
+        if (object instanceof String) {
+            return (String) object;
+        }
+        if ((object instanceof Number) || (object instanceof Boolean)) {
+            return object.toString();
+        }
+        throw new IllegalArgumentException("Unsupported type for string value: " + object.getClass());
+    }
+
+    @Nullable
+    public static Map<String, Object> getMap(@Nullable Object obj, @NonNull String str) {
+        return getMap(obj, str, null);
+    }
+
+    @Nullable
+    public static Map<String, Object> getMap(@Nullable Object obj, @NonNull String str, @Nullable Map<String, Object> map) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return map;
+        }
+        if (object instanceof Map) {
+            return (Map) object;
+        }
+        throw new IllegalArgumentException("Unsupported type for map value: " + object.getClass());
+    }
+
+    public static List<Object> getList(@Nullable Object obj, @NonNull String str) {
+        return getList(obj, str, null);
+    }
+
+    @Nullable
+    public static List<Object> getList(@Nullable Object obj, @NonNull String str, @Nullable List<Object> list) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return list;
+        }
+        if (object instanceof List) {
+            return (List) object;
+        }
+        throw new IllegalArgumentException("Unsupported type for list value: " + object.getClass());
+    }
+
+    public static Object getObject(@Nullable Object obj, @NonNull String str) {
+        return getObject(obj, str, null);
+    }
+
+    @Nullable
+    public static Object getObject(@Nullable Object obj, @NonNull String str, @Nullable Object obj2) {
+        if (obj == null) {
+            return obj2;
+        }
+        for (String str2 : splitPath(str)) {
+            if (obj == null) {
+                return obj2;
+            }
+            obj = ((Map) obj).get(str2);
+        }
+        return obj;
+    }
+
+    @NonNull
+    private static String[] splitPath(@NonNull String str) {
+        return str.split("\\.");
+    }
+
+    @Nullable
+    public static String getCustomCrossPromoQueries(@NonNull Object obj) {
+        return getString(obj, Consts.CROSSPROMO_CUSTOMDATAP_KEY_NAME, null);
+    }
+
+    @NonNull
+    public static Object setCustomCrossPromoQueries(@NonNull String str, @NonNull Map map) {
+        map.put(Consts.CROSSPROMO_CUSTOMDATAP_KEY_NAME, str);
+        return map;
+    }
+
+    @Nullable
+    public static Map<String, Object> configSdk(@NonNull Map<String, Object> map) {
+        return getMap(map, "csdk.gluAds");
+    }
+
+    @Nullable
+    public static Map<String, Object> configComponents(@NonNull Map<String, Object> map) {
+        return getMap(configSdk(map), "components");
+    }
+
+    @Nullable
+    public static Map<String, Object> configDisabled(@NonNull Map<String, Object> map) {
+        return getMap(configSdk(map), "disabled");
+    }
+
+    public static Map<String, Object> getConfigMapVariant(Map<String, Object> map, String str, boolean z, Map<String, Object> map2) {
+        Map<String, Object> map3 = getMap(map, str + (z ? "Tablet" : "Phone"), null);
+        return map3 != null ? map3 : getMap(map, str, map2);
+    }
+
+    public static int getIntegerVariant(Map<String, Object> map, String str, boolean z, int i) {
+        int integer = getInteger(map, str + (z ? "Tablet" : "Phone"), -1);
+        return integer > 0 ? integer : getInteger(map, str, i);
+    }
+
+    public static boolean shouldSendImpressionData(Map<String, Object> map) {
+        return !getBoolean(map, Consts.KEY_NAME_IMPRESSION_DATA, false);
+    }
+}

decompiled-community/sources/csdk/gluads/util/DeviceUtil.java

@@ -0,0 +1,85 @@
+package csdk.gluads.util;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.graphics.PointF;
+import android.hardware.display.DisplayManager;
+import android.util.DisplayMetrics;
+import android.view.Display;
+import android.view.WindowManager;
+
+/* loaded from: classes4.dex */
+public class DeviceUtil {
+    private static final IDefaultDisplayMetricsGetter sDMGetter = defaultDisplayMetricsGetter();
+
+    public interface IDefaultDisplayMetricsGetter {
+        DisplayMetrics defaultDisplayMetrics(Context context);
+    }
+
+    public static boolean isTablet(Context context) {
+        PointF defaultDisplayPhysicalSizeInInches = defaultDisplayPhysicalSizeInInches(context);
+        return isTablet(defaultDisplayPhysicalSizeInInches.x, defaultDisplayPhysicalSizeInInches.y);
+    }
+
+    public static boolean isTablet(float f, float f2) {
+        return Math.sqrt((double) ((f * f) + (f2 * f2))) >= 6.9d;
+    }
+
+    public static PointF defaultDisplayPhysicalSizeInInches(Context context) {
+        return physicalSizeInInches(sDMGetter.defaultDisplayMetrics(context));
+    }
+
+    public static PointF physicalSizeInInches(DisplayMetrics displayMetrics) {
+        return new PointF(displayMetrics.widthPixels / displayMetrics.xdpi, displayMetrics.heightPixels / displayMetrics.ydpi);
+    }
+
+    private static IDefaultDisplayMetricsGetter defaultDisplayMetricsGetter() {
+        return new API17_DefaultDisplayMetricsGetter();
+    }
+
+    @TargetApi(17)
+    public static class API17 {
+        public static Display defaultDisplay(Context context) {
+            return ((DisplayManager) context.getSystemService("display")).getDisplay(0);
+        }
+
+        public static DisplayMetrics realDisplayMetrics(Display display) {
+            DisplayMetrics displayMetrics = new DisplayMetrics();
+            display.getRealMetrics(displayMetrics);
+            return displayMetrics;
+        }
+    }
+
+    public static class API1 {
+        public static Display defaultDisplay(Context context) {
+            return ((WindowManager) context.getSystemService("window")).getDefaultDisplay();
+        }
+
+        public static DisplayMetrics realDisplayMetrics(Display display) {
+            DisplayMetrics displayMetrics = new DisplayMetrics();
+            display.getMetrics(displayMetrics);
+            return displayMetrics;
+        }
+    }
+
+    @TargetApi(17)
+    public static class API17_DefaultDisplayMetricsGetter implements IDefaultDisplayMetricsGetter {
+        private API17_DefaultDisplayMetricsGetter() {
+        }
+
+        @Override // csdk.gluads.util.DeviceUtil.IDefaultDisplayMetricsGetter
+        public DisplayMetrics defaultDisplayMetrics(Context context) {
+            return API17.realDisplayMetrics(API17.defaultDisplay(context));
+        }
+    }
+
+    public static class API1_DefaultDisplayMetricsGetter implements IDefaultDisplayMetricsGetter {
+        private API1_DefaultDisplayMetricsGetter() {
+        }
+
+        @Override // csdk.gluads.util.DeviceUtil.IDefaultDisplayMetricsGetter
+        public DisplayMetrics defaultDisplayMetrics(Context context) {
+            return API1.realDisplayMetrics(API1.defaultDisplay(context));
+        }
+    }
+}

decompiled-community/sources/csdk/gluads/util/Futures.java

@@ -0,0 +1,160 @@
+package csdk.gluads.util;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes4.dex */
+public class Futures {
+    @NonNull
+    public static <V> Future<V> successful(V v) {
+        return new SuccessfulFuture(v);
+    }
+
+    @NonNull
+    public static <V> Future<V> failed(Throwable th) {
+        return new FailedFuture(th);
+    }
+
+    @NonNull
+    public static <V> SettableFuture<V> settable() {
+        return new SettableFuture<>();
+    }
+
+    public static class SuccessfulFuture<V> implements Future<V> {
+        public final V value;
+
+        @Override // java.util.concurrent.Future
+        public boolean cancel(boolean z) {
+            return false;
+        }
+
+        @Override // java.util.concurrent.Future
+        public V get() throws InterruptedException, ExecutionException {
+            return this.value;
+        }
+
+        @Override // java.util.concurrent.Future
+        public boolean isCancelled() {
+            return false;
+        }
+
+        @Override // java.util.concurrent.Future
+        public boolean isDone() {
+            return true;
+        }
+
+        private SuccessfulFuture(V v) {
+            this.value = v;
+        }
+
+        @Override // java.util.concurrent.Future
+        public V get(long j, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
+            return get();
+        }
+    }
+
+    public static class FailedFuture<V> implements Future<V> {
+        public final Throwable failure;
+
+        @Override // java.util.concurrent.Future
+        public boolean cancel(boolean z) {
+            return false;
+        }
+
+        @Override // java.util.concurrent.Future
+        public boolean isCancelled() {
+            return false;
+        }
+
+        @Override // java.util.concurrent.Future
+        public boolean isDone() {
+            return true;
+        }
+
+        public FailedFuture(Throwable th) {
+            this.failure = th;
+        }
+
+        @Override // java.util.concurrent.Future
+        public V get() throws InterruptedException, ExecutionException {
+            throw new ExecutionException(this.failure);
+        }
+
+        @Override // java.util.concurrent.Future
+        public V get(long j, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
+            return get();
+        }
+    }
+
+    public static class SettableFuture<V> implements Future<V> {
+        private static final int DONE_RES_CANCELLED = 3;
+        private static final int DONE_RES_COMPLETED = 1;
+        private static final int DONE_RES_FAILED = 2;
+        private static final int DONE_RES_INITIAL = 0;
+        private volatile int doneRes;
+        private volatile Object result;
+
+        @Override // java.util.concurrent.Future
+        public boolean isCancelled() {
+            return false;
+        }
+
+        @Override // java.util.concurrent.Future
+        public boolean isDone() {
+            return this.doneRes != 0;
+        }
+
+        @Override // java.util.concurrent.Future
+        public V get() {
+            throw new UnsupportedOperationException("Blocking get is not supported.");
+        }
+
+        @Override // java.util.concurrent.Future
+        public V get(long j, TimeUnit timeUnit) throws ExecutionException, TimeoutException {
+            if (j > 0) {
+                throw new UnsupportedOperationException("Blocking get() is not supported.");
+            }
+            if (!isDone()) {
+                throw new TimeoutException();
+            }
+            if (this.doneRes == 3) {
+                throw new CancellationException();
+            }
+            if (this.doneRes != 2) {
+                return (V) this.result;
+            }
+            throw new ExecutionException((Throwable) this.result);
+        }
+
+        @Override // java.util.concurrent.Future
+        public synchronized boolean cancel(boolean z) {
+            if (isDone()) {
+                return false;
+            }
+            this.doneRes = 3;
+            return true;
+        }
+
+        public synchronized boolean set(V v) {
+            if (isDone()) {
+                return false;
+            }
+            this.result = v;
+            this.doneRes = 1;
+            return true;
+        }
+
+        public synchronized boolean setException(Throwable th) {
+            if (isDone()) {
+                return false;
+            }
+            this.result = th;
+            this.doneRes = 2;
+            return true;
+        }
+    }
+}

decompiled-community/sources/csdk/gluads/util/GluActivityLifecycleCallbacks.java

@@ -0,0 +1,89 @@
+package csdk.gluads.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 GluActivityLifecycleCallbacks 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 GluActivityLifecycleCallbacks(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.gluads.util.GluActivityLifecycleCallbacks.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (GluActivityLifecycleCallbacks.this.mApplication != null) {
+                    GluActivityLifecycleCallbacks.this.mApplication.unregisterActivityLifecycleCallbacks(this);
+                }
+                GluActivityLifecycleCallbacks.this.mApplication = null;
+                GluActivityLifecycleCallbacks.this.mOnActivityCallback = null;
+                GluActivityLifecycleCallbacks.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-community/sources/csdk/gluads/util/GluAdsCrashlytics.java

@@ -0,0 +1,26 @@
+package csdk.gluads.util;
+
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+
+/* loaded from: classes4.dex */
+public class GluAdsCrashlytics {
+    public static void setCustomKeyString(String str, String str2) {
+        try {
+            Object invoke = FirebaseCrashlytics.class.getMethod("getInstance", new Class[0]).invoke(null, new Object[0]);
+            if (invoke != null) {
+                FirebaseCrashlytics.class.getMethod("setCustomKey", String.class, String.class).invoke(invoke, str, str2);
+            }
+        } catch (Exception unused) {
+        }
+    }
+
+    public static void logMessage(String str) {
+        try {
+            Object invoke = FirebaseCrashlytics.class.getMethod("getInstance", new Class[0]).invoke(null, new Object[0]);
+            if (invoke != null) {
+                FirebaseCrashlytics.class.getMethod("log", String.class).invoke(invoke, str);
+            }
+        } catch (Exception unused) {
+        }
+    }
+}

decompiled-community/sources/csdk/gluads/util/IAction1.java

@@ -0,0 +1,6 @@
+package csdk.gluads.util;
+
+/* loaded from: classes4.dex */
+public interface IAction1<T> {
+    void apply(T t);
+}

decompiled-community/sources/csdk/gluads/util/IAction2.java

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

decompiled-community/sources/csdk/gluads/util/ISerializableJsonObject.java

@@ -0,0 +1,9 @@
+package csdk.gluads.util;
+
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public interface ISerializableJsonObject {
+    void write(JSONStringer jSONStringer) throws JSONException;
+}

decompiled-community/sources/csdk/gluads/util/JsonUtil.java

@@ -0,0 +1,304 @@
+package csdk.gluads.util;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+import android.util.JsonReader;
+import android.util.JsonToken;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import csdk.gluads.Consts;
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+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 */
+public class JsonUtil {
+    public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+        return Api11.parseJsonObject(str);
+    }
+
+    public static Map<String, Object> toMap(Bundle bundle) {
+        return (Map) toSimpleJavaTypes(bundle);
+    }
+
+    public static Map<String, Object> toMap(JSONObject jSONObject) {
+        return (Map) toSimpleJavaTypes(jSONObject);
+    }
+
+    public static String toJson(Object obj) {
+        JSONStringer jSONStringer = new JSONStringer();
+        try {
+            value(jSONStringer, obj);
+            return jSONStringer.toString();
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    public static void optKeyValue(JSONStringer jSONStringer, String str, Object obj) throws JSONException {
+        if (obj != null) {
+            jSONStringer.key(str);
+            value(jSONStringer, obj);
+        }
+    }
+
+    public static void value(JSONStringer jSONStringer, Object obj) throws JSONException {
+        if (obj == null) {
+            jSONStringer.value(obj);
+            return;
+        }
+        if (obj instanceof ISerializableJsonObject) {
+            jSONStringer.object();
+            ((ISerializableJsonObject) obj).write(jSONStringer);
+            jSONStringer.endObject();
+            return;
+        }
+        if ((obj instanceof Number) || (obj instanceof Boolean) || (obj instanceof CharSequence) || (obj instanceof Character)) {
+            jSONStringer.value(obj);
+            return;
+        }
+        if (obj instanceof Map) {
+            serializeMap(jSONStringer, (Map) obj);
+            return;
+        }
+        if (obj instanceof Iterable) {
+            serializeIterable(jSONStringer, (Iterable) obj);
+            return;
+        }
+        if (obj.getClass().isArray()) {
+            serializeArray(jSONStringer, obj);
+        } else if (obj instanceof Throwable) {
+            serializeThrowable(jSONStringer, (Throwable) obj);
+        } else {
+            serializeDefaultObject(jSONStringer, obj);
+        }
+    }
+
+    private static void serializeMap(JSONStringer jSONStringer, Map<?, ?> map) throws JSONException {
+        Iterator<?> it = map.keySet().iterator();
+        while (it.hasNext()) {
+            if (!(it.next() instanceof CharSequence)) {
+                serializeMapWithNonStringKeys(jSONStringer, map);
+                return;
+            }
+        }
+        jSONStringer.object();
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            jSONStringer.key(entry.getKey().toString());
+            value(jSONStringer, entry.getValue());
+        }
+        jSONStringer.endObject();
+    }
+
+    private static void serializeMapWithNonStringKeys(JSONStringer jSONStringer, Map<?, ?> map) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "cls", "flatmap");
+        jSONStringer.key(Consts.KEY_TAPJOY_USER_ID_VERSION).array();
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            jSONStringer.array();
+            value(jSONStringer, entry.getKey());
+            value(jSONStringer, entry.getValue());
+            jSONStringer.endArray();
+        }
+        jSONStringer.endArray();
+        jSONStringer.endObject();
+    }
+
+    private static void serializeIterable(JSONStringer jSONStringer, Iterable<?> iterable) throws JSONException {
+        jSONStringer.array();
+        Iterator<?> it = iterable.iterator();
+        while (it.hasNext()) {
+            value(jSONStringer, it.next());
+        }
+        jSONStringer.endArray();
+    }
+
+    private static void serializeArray(JSONStringer jSONStringer, Object obj) throws JSONException {
+        int length = Array.getLength(obj);
+        jSONStringer.array();
+        for (int i = 0; i < length; i++) {
+            value(jSONStringer, Array.get(obj, i));
+        }
+        jSONStringer.endArray();
+    }
+
+    private static void serializeThrowable(JSONStringer jSONStringer, Throwable th) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "cls", th.getClass().getSimpleName());
+        optKeyValue(jSONStringer, InneractiveMediationDefs.GENDER_MALE, th.getMessage());
+        jSONStringer.endObject();
+    }
+
+    private static void serializeDefaultObject(JSONStringer jSONStringer, Object obj) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "str", obj.toString());
+        jSONStringer.endObject();
+    }
+
+    private static Object toSimpleJavaTypes(Object obj) {
+        if (obj == null || (obj instanceof String) || (obj instanceof Number) || (obj instanceof Boolean)) {
+            return obj;
+        }
+        if ((obj instanceof CharSequence) || (obj instanceof Character)) {
+            return obj.toString();
+        }
+        if (obj instanceof Iterable) {
+            ArrayList arrayList = new ArrayList();
+            Iterator it = ((Iterable) obj).iterator();
+            while (it.hasNext()) {
+                arrayList.add(toSimpleJavaTypes(it.next()));
+            }
+            return arrayList;
+        }
+        int i = 0;
+        if (obj.getClass().isArray()) {
+            ArrayList arrayList2 = new ArrayList();
+            int length = Array.getLength(obj);
+            while (i < length) {
+                arrayList2.add(toSimpleJavaTypes(Array.get(obj, i)));
+                i++;
+            }
+            return arrayList2;
+        }
+        if (obj instanceof Bundle) {
+            Map createMap = Common.createMap();
+            Bundle bundle = (Bundle) obj;
+            for (String str : bundle.keySet()) {
+                createMap.put(str, toSimpleJavaTypes(bundle.get(str)));
+            }
+            return createMap;
+        }
+        if (obj instanceof JSONArray) {
+            ArrayList arrayList3 = new ArrayList();
+            JSONArray jSONArray = (JSONArray) obj;
+            while (i < jSONArray.length()) {
+                arrayList3.add(toSimpleJavaTypes(jSONArray.opt(i)));
+                i++;
+            }
+            return arrayList3;
+        }
+        if (obj instanceof JSONObject) {
+            Map createMap2 = Common.createMap();
+            JSONObject jSONObject = (JSONObject) obj;
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                createMap2.put(next, toSimpleJavaTypes(jSONObject.opt(next)));
+            }
+            return createMap2;
+        }
+        if (obj == JSONObject.NULL) {
+            return null;
+        }
+        throw new IllegalArgumentException(String.format("Unsupported type %s", obj.getClass()));
+    }
+
+    @TargetApi(11)
+    public static class Api11 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            JsonReader jsonReader;
+            JsonReader jsonReader2 = null;
+            try {
+                try {
+                    jsonReader = new JsonReader(new StringReader(str));
+                } catch (Throwable th) {
+                    th = th;
+                }
+            } catch (IOException e) {
+                e = e;
+            }
+            try {
+                jsonReader.setLenient(true);
+                Map<String, Object> parseJsonObject = parseJsonObject(jsonReader);
+                try {
+                    jsonReader.close();
+                    return parseJsonObject;
+                } catch (IOException e2) {
+                    throw Common.propagate(e2);
+                }
+            } catch (IOException e3) {
+                e = e3;
+                throw Common.propagate(e);
+            } catch (Throwable th2) {
+                th = th2;
+                jsonReader2 = jsonReader;
+                if (jsonReader2 != null) {
+                    try {
+                        jsonReader2.close();
+                    } catch (IOException e4) {
+                        throw Common.propagate(e4);
+                    }
+                }
+                throw th;
+            }
+        }
+
+        public static Object parseJsonValue(JsonReader jsonReader) throws JSONException, IOException {
+            JsonToken peek = jsonReader.peek();
+            if (peek == JsonToken.BEGIN_OBJECT) {
+                return parseJsonObject(jsonReader);
+            }
+            if (peek == JsonToken.BEGIN_ARRAY) {
+                return parseJsonArray(jsonReader);
+            }
+            if (peek == JsonToken.BOOLEAN) {
+                return Boolean.valueOf(jsonReader.nextBoolean());
+            }
+            if (peek == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return null;
+            }
+            if (peek == JsonToken.NUMBER) {
+                String nextString = jsonReader.nextString();
+                if (nextString.contains(Consts.STRING_PERIOD) || nextString.contains("e") || nextString.contains("E")) {
+                    return Double.valueOf(Double.parseDouble(nextString));
+                }
+                return Long.valueOf(Long.parseLong(nextString));
+            }
+            if (peek == JsonToken.STRING) {
+                return jsonReader.nextString();
+            }
+            throw new JSONException("Unexpected token " + peek);
+        }
+
+        public static Map<String, Object> parseJsonObject(JsonReader jsonReader) throws JSONException, IOException {
+            Map<String, Object> createMap = Common.createMap();
+            jsonReader.beginObject();
+            while (true) {
+                JsonToken peek = jsonReader.peek();
+                if (peek == JsonToken.END_OBJECT) {
+                    jsonReader.endObject();
+                    return createMap;
+                }
+                if (peek == JsonToken.NAME) {
+                    createMap.put(jsonReader.nextName(), parseJsonValue(jsonReader));
+                } else {
+                    throw new JSONException("Expected } or name but found " + peek);
+                }
+            }
+        }
+
+        public static List<Object> parseJsonArray(JsonReader jsonReader) throws JSONException, IOException {
+            ArrayList arrayList = new ArrayList();
+            jsonReader.beginArray();
+            while (jsonReader.peek() != JsonToken.END_ARRAY) {
+                arrayList.add(parseJsonValue(jsonReader));
+            }
+            jsonReader.endArray();
+            return arrayList;
+        }
+    }
+
+    public static class Api1 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            return JsonUtil.toMap(new JSONObject(str));
+        }
+    }
+}

decompiled-community/sources/csdk/gluads/util/PlacementInfo.java

@@ -0,0 +1,12 @@
+package csdk.gluads.util;
+
+/* loaded from: classes4.dex */
+public class PlacementInfo {
+    public String mName;
+    public String mSource;
+
+    public PlacementInfo(String str, String str2) {
+        this.mSource = str;
+        this.mName = str2;
+    }
+}

decompiled-community/sources/csdk/gluads/util/RewardUtil.java

@@ -0,0 +1,70 @@
+package csdk.gluads.util;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.Consts;
+import csdk.gluads.Reward;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class RewardUtil {
+    @NonNull
+    public static Map<String, Reward> parseRewardListFromConfig(@Nullable Map<String, Object> map) {
+        Map<String, Reward> createMap = Common.createMap();
+        if (map != null) {
+            for (Map.Entry<String, Object> entry : map.entrySet()) {
+                String key = entry.getKey();
+                createMap.put(key, toReward(key, entry.getValue()));
+            }
+        }
+        return createMap;
+    }
+
+    @NonNull
+    public static Reward toReward(@NonNull String str, @NonNull Object obj) {
+        return new Reward(Common.uuid(), str, null, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, ConfigUtil.getString(obj, "reward"), Integer.valueOf(ConfigUtil.getInteger(obj, "amount")).intValue());
+    }
+
+    public static PlacementInfo getPlacement(@NonNull PlacementInfo placementInfo, @NonNull Map<String, Object> map, Map<String, Object> map2, String str) {
+        Object obj;
+        int integer;
+        String str2;
+        String str3;
+        Object obj2;
+        synchronized (map) {
+            obj = map.get(placementInfo.mName);
+        }
+        PlacementInfo placementInfo2 = new PlacementInfo(placementInfo.mSource, placementInfo.mName);
+        if (obj != null && (obj instanceof String)) {
+            placementInfo2.mName = (String) obj;
+        } else {
+            if (obj != null && (obj instanceof Map)) {
+                str3 = ConfigUtil.getString(obj, "reward", null);
+                integer = ConfigUtil.getInteger(obj, "amount", 0);
+                str2 = ConfigUtil.getString(obj, "hash", null);
+                placementInfo2.mSource = "SDK (penguin)";
+            } else {
+                String string = ConfigUtil.getString(map2, "reward", null);
+                integer = ConfigUtil.getInteger(map2, "amount", 0);
+                String string2 = ConfigUtil.getString(map2, "hash", null);
+                if (string != null) {
+                    placementInfo2.mSource = "APP";
+                }
+                str2 = string2;
+                str3 = string;
+            }
+            if (str2 != null) {
+                placementInfo2.mName = str2;
+            } else if (str3 != null) {
+                placementInfo2.mName = str3 + str + String.valueOf(integer);
+                synchronized (map) {
+                    obj2 = map.get(placementInfo2.mName);
+                }
+                if (obj2 != null && (obj2 instanceof String)) {
+                    placementInfo2.mName = (String) obj2;
+                }
+            }
+        }
+        return placementInfo2;
+    }
+}

decompiled-community/sources/csdk/gluads/util/broadcastmanager/DummyBroadcastManger.java

@@ -0,0 +1,16 @@
+package csdk.gluads.util.broadcastmanager;
+
+import android.content.IntentFilter;
+
+/* loaded from: classes4.dex */
+public class DummyBroadcastManger implements IBroadcastManger {
+    public static final IBroadcastManger INSTANCE = new DummyBroadcastManger();
+
+    @Override // csdk.gluads.util.broadcastmanager.IBroadcastManger
+    public void subscribe(ISubscriber iSubscriber, Iterable<IntentFilter> iterable) {
+    }
+
+    @Override // csdk.gluads.util.broadcastmanager.IBroadcastManger
+    public void unsubscribe() {
+    }
+}

decompiled-community/sources/csdk/gluads/util/broadcastmanager/GluBroadcastManager.java

@@ -0,0 +1,79 @@
+package csdk.gluads.util.broadcastmanager;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+import csdk.gluads.util.Common;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.Iterator;
+
+/* loaded from: classes4.dex */
+public class GluBroadcastManager implements IBroadcastManger {
+    private static volatile IBroadcastManger sInstance;
+    private final LocalBroadcastManager mLbm;
+    private BroadcastReceiver mReceiver;
+
+    public static boolean isSupported() {
+        return true;
+    }
+
+    public GluBroadcastManager(Context context) {
+        this.mLbm = LocalBroadcastManager.getInstance(context);
+    }
+
+    public static IBroadcastManger getInstance(Context context) {
+        Common.require(context != null, "context can't be null.");
+        if (sInstance == null) {
+            synchronized (GluBroadcastManager.class) {
+                try {
+                    if (sInstance == null) {
+                        sInstance = new GluBroadcastManager(context);
+                    }
+                } finally {
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    @Override // csdk.gluads.util.broadcastmanager.IBroadcastManger
+    public void subscribe(ISubscriber iSubscriber, Iterable<IntentFilter> iterable) {
+        Common.require(iSubscriber != null, "weakSubscriber can't be null.");
+        Common.require(iterable != null, "filters can't be null.");
+        unsubscribe();
+        this.mReceiver = new SubscriberAdapter(iSubscriber);
+        Iterator<IntentFilter> it = iterable.iterator();
+        while (it.hasNext()) {
+            this.mLbm.registerReceiver(this.mReceiver, it.next());
+        }
+    }
+
+    @Override // csdk.gluads.util.broadcastmanager.IBroadcastManger
+    public void unsubscribe() {
+        BroadcastReceiver broadcastReceiver = this.mReceiver;
+        if (broadcastReceiver != null) {
+            this.mLbm.unregisterReceiver(broadcastReceiver);
+        }
+    }
+
+    public class SubscriberAdapter extends BroadcastReceiver {
+        private final Reference<ISubscriber> mSubscriber;
+
+        public SubscriberAdapter(ISubscriber iSubscriber) {
+            this.mSubscriber = new WeakReference(iSubscriber);
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            ISubscriber iSubscriber = this.mSubscriber.get();
+            if (iSubscriber != null) {
+                iSubscriber.onReceive(GluBroadcastManager.this, intent);
+            } else {
+                GluBroadcastManager.this.unsubscribe();
+            }
+        }
+    }
+}

decompiled-community/sources/csdk/gluads/util/broadcastmanager/IBroadcastManger.java

@@ -0,0 +1,10 @@
+package csdk.gluads.util.broadcastmanager;
+
+import android.content.IntentFilter;
+
+/* loaded from: classes4.dex */
+public interface IBroadcastManger {
+    void subscribe(ISubscriber iSubscriber, Iterable<IntentFilter> iterable);
+
+    void unsubscribe();
+}

decompiled-community/sources/csdk/gluads/util/broadcastmanager/ISubscriber.java

@@ -0,0 +1,8 @@
+package csdk.gluads.util.broadcastmanager;
+
+import android.content.Intent;
+
+/* loaded from: classes4.dex */
+public interface ISubscriber {
+    void onReceive(IBroadcastManger iBroadcastManger, Intent intent);
+}

decompiled-community/sources/csdk/gluads/util/log/YLogger.java

@@ -0,0 +1,132 @@
+package csdk.gluads.util.log;
+
+import android.text.TextUtils;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.JsonUtil;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class YLogger {
+    private final Logger log;
+
+    public YLogger(Logger logger) {
+        this.log = logger;
+    }
+
+    public void t(String str, Object... objArr) {
+        if (isTraceEnabled()) {
+            this.log.log(Level.FINEST, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public void d(String str, Object... objArr) {
+        if (isDebugEnabled()) {
+            this.log.log(Level.FINE, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public void i(String str, Object... objArr) {
+        if (isInfoEnabled()) {
+            this.log.log(Level.INFO, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public void w(String str, Object... objArr) {
+        if (isWarnEnabled()) {
+            this.log.log(Level.WARNING, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public void e(String str, Object... objArr) {
+        if (isErrorEnabled()) {
+            this.log.log(Level.SEVERE, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public boolean isTraceEnabled() {
+        return this.log.isLoggable(Level.FINEST);
+    }
+
+    public boolean isDebugEnabled() {
+        return this.log.isLoggable(Level.FINE);
+    }
+
+    public boolean isInfoEnabled() {
+        return this.log.isLoggable(Level.INFO);
+    }
+
+    public boolean isWarnEnabled() {
+        return this.log.isLoggable(Level.WARNING);
+    }
+
+    public boolean isErrorEnabled() {
+        return this.log.isLoggable(Level.SEVERE);
+    }
+
+    private static String format(String str, Object... objArr) {
+        try {
+            JSONStringer object = new JSONStringer().array().value(str).object();
+            appendPlistToJson(object, objArr);
+            Object[] plistTail = plistTail(objArr);
+            if (plistTail != null) {
+                appendPlistToJson(object, plistTail);
+            }
+            object.endObject().endArray();
+            return "#evu" + object.toString();
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    private static Throwable findThrowable(Object... objArr) {
+        Throwable findThrowableNoTail = findThrowableNoTail(objArr);
+        if (findThrowableNoTail != null) {
+            return findThrowableNoTail;
+        }
+        Object[] plistTail = plistTail(objArr);
+        if (plistTail != null) {
+            return findThrowableNoTail(plistTail);
+        }
+        return null;
+    }
+
+    private static Throwable findThrowableNoTail(Object... objArr) {
+        int length = objArr.length - (objArr.length % 2);
+        for (int i = 0; i < length; i += 2) {
+            if (TextUtils.equals((String) objArr[i], "e")) {
+                Object obj = objArr[i + 1];
+                if (obj instanceof Throwable) {
+                    return (Throwable) obj;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static Object[] plistTail(Object[] objArr) {
+        int length = objArr.length;
+        int i = length - (length % 2);
+        if (i < length) {
+            Object obj = objArr[i];
+            if (obj instanceof Object[]) {
+                return (Object[]) obj;
+            }
+        }
+        return null;
+    }
+
+    private static void appendPlistToJson(JSONStringer jSONStringer, Object[] objArr) throws JSONException {
+        int length = objArr.length;
+        int i = length - (length % 2);
+        for (int i2 = 0; i2 < i; i2 += 2) {
+            Object obj = objArr[i2];
+            Object obj2 = objArr[i2 + 1];
+            if (obj instanceof String) {
+                JsonUtil.optKeyValue(jSONStringer, (String) obj, obj2);
+            }
+        }
+    }
+}

decompiled-community/sources/csdk/gluads/util/log/YLoggerFactory.java

@@ -0,0 +1,14 @@
+package csdk.gluads.util.log;
+
+import java.util.logging.Logger;
+
+/* loaded from: classes4.dex */
+public class YLoggerFactory {
+    public static YLogger getLogger(String str) {
+        return new YLogger(Logger.getLogger(str));
+    }
+
+    public static YLogger getLogger(Class<?> cls) {
+        return getLogger(cls.getName());
+    }
+}

decompiled-community/sources/csdk/gluads/util/log/YLoggers.java

@@ -0,0 +1,81 @@
+package csdk.gluads.util.log;
+
+import android.os.Build;
+import com.ironsource.nb;
+import csdk.gluads.Consts;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public class YLoggers {
+    private static final int CALLER_INDEX = 1;
+
+    public static void sdkVersion(YLogger yLogger, String str, String str2) {
+        yLogger.i("SDK.VERSION", nb.q, str, Consts.KEY_TAPJOY_USER_ID_VERSION, str2);
+    }
+
+    public static void sdkConfiguration(YLogger yLogger, String str, Object... objArr) {
+        yLogger.i("CONFIG.SDK." + str, objArr);
+    }
+
+    public static void componentConfiguration(YLogger yLogger, String str, Object... objArr) {
+        yLogger.i("CONFIG.COMPONENT." + str, objArr);
+    }
+
+    public static void sdkConfigurationError(YLogger yLogger, String str, Object... objArr) {
+        yLogger.i("CONFIG.SDK." + str, objArr);
+    }
+
+    public static void componentConfigurationError(YLogger yLogger, String str, Object... objArr) {
+        yLogger.e("CONFIG.COMPONENT." + str, objArr);
+    }
+
+    public static void ctor(YLogger yLogger, Object... objArr) {
+        yLogger.t("TRACE.METHOD.INVOKE", nb.q, "#ctor", "args", objArr);
+    }
+
+    public static void method(YLogger yLogger, Object... objArr) {
+        if (yLogger.isTraceEnabled()) {
+            StackTraceElement[] stackTrace = new Throwable().getStackTrace();
+            if (stackTrace.length > 1) {
+                yLogger.t("TRACE.METHOD.INVOKE", nb.q, stackTrace[1].getMethodName(), "args", objArr);
+            }
+        }
+    }
+
+    public static void warn(YLogger yLogger, Throwable th, String str, Object... objArr) {
+        yLogger.w(str + ".ERROR", concatArrays(objArr, new Object[]{"e", th}));
+    }
+
+    public static void error(YLogger yLogger, Throwable th, String str, Object... objArr) {
+        yLogger.e(str + ".ERROR", concatArrays(objArr, new Object[]{"e", th}));
+    }
+
+    public static void beginAsync(YLogger yLogger, String str, Object... objArr) {
+        yLogger.d("ASYNC.BEGIN", concatArrays(new Object[]{nb.q, str}, objArr));
+    }
+
+    public static void endAsync(YLogger yLogger, String str, Object... objArr) {
+        yLogger.d("ASYNC.END", concatArrays(new Object[]{nb.q, str}, objArr));
+    }
+
+    public static void failAsync(YLogger yLogger, Throwable th, String str, Object... objArr) {
+        yLogger.w("ASYNC.ERROR", concatArrays(new Object[]{nb.q, str}, concatArrays(objArr, new Object[]{"e", th})));
+    }
+
+    private static Object[] concatArrays(Object[] objArr, Object[] objArr2) {
+        if (objArr2 == null || objArr2.length == 0) {
+            return objArr;
+        }
+        if (objArr == null || objArr.length == 0) {
+            return objArr2;
+        }
+        Object[] objArr3 = new Object[objArr.length + objArr2.length];
+        System.arraycopy(objArr, 0, objArr3, 0, objArr.length);
+        System.arraycopy(objArr2, 0, objArr3, objArr.length, objArr2.length);
+        return objArr3;
+    }
+
+    public static void cpuFamily(YLogger yLogger) {
+        yLogger.i("CPU.FAMILY", "ARCH", System.getProperty("os.arch"), "SUPPORTED_ABIS", Arrays.toString(Build.SUPPORTED_ABIS));
+    }
+}