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/gluads/BuildConfig.java

@@ -0,0 +1,9 @@
+package csdk.gluads;
+
+/* loaded from: classes4.dex */
+public final class BuildConfig {
+    public static final String BUILD_TYPE = "release";
+    public static final boolean DEBUG = false;
+    public static final String LIBRARY_PACKAGE_NAME = "csdk.gluads";
+    public static final String VERSION_NAME = "7.6.4-ec99fc8";
+}

decompiled/sources/csdk/gluads/Consts.java

@@ -0,0 +1,96 @@
+package csdk.gluads;
+
+/* loaded from: classes4.dex */
+public class Consts {
+    public static final String ADVERTISEMENT_TYPE_BANNER = "banner";
+    public static final String ADVERTISEMENT_TYPE_INTERSTITIAL = "interstitial";
+    public static final String ADVERTISEMENT_TYPE_NATIVE_AD = "nativeAd";
+    public static final String ADVERTISEMENT_TYPE_OFFER_WALL = "offerWall";
+    public static final String ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL = "rewardedInterstitial";
+    public static final String AD_NETWORK = "adNetwork";
+    public static final int APP_CUSTOM_DATA_LIMIT = 5120;
+    public static final String CREATIVE_ID = "creativeId";
+    public static final String CROSSPROMO_CUSTOMDATAP_KEY_NAME = "customDataCrossPromo";
+    public static final String DEBUG_PLACEMENT = "max_debugger";
+    public static final String ENABLE_GOOGLE_TEST_ADS = "enableGoogleTestAds";
+    public static final String EXTRA_KEYWORDS = "keywords";
+    public static final String EXTRA_KEYWORDS_AGE = "keyword_age";
+    public static final int GEMS_CUSTOM_DATA_LIMIT = 6144;
+    public static final String GLOBAL_FREQUENCY_CAPPING = "globalFrequencyCapping";
+    public static final int IRONSOURCE_DYNAMIC_USER_ID_MAX_LENGTH = 128;
+    public static final String IS_CROSS_PROMO = "isCrossPromo";
+    public static final String IS_LOADED_IGNORE_FREQUENCYCAPPING = "isLoadedIgnoreFrequencyCapping";
+    public static final String KEY_NAME_ADTYPE = "adType";
+    public static final String KEY_NAME_AD_UNIT_ID = "adUnit";
+    public static final String KEY_NAME_ANALYTICS_DEVICE_ID = "analyticDeviceId";
+    public static final String KEY_NAME_ANALYTICS_GAME_NAME = "analyticGameName";
+    public static final String KEY_NAME_ERROR_CODE = "errorCode";
+    public static final String KEY_NAME_FREQUENCY_REFRESH = "frequencyRefreshRequired";
+    public static final String KEY_NAME_GAMEDATA = "gameData";
+    public static final String KEY_NAME_GEMSDATA = "gemsData";
+    public static final String KEY_NAME_IMPRESSION_DATA = "impressionData";
+    public static final String KEY_NAME_PLAYERID = "playerId";
+    public static final String KEY_NAME_PUB_REVENUE = "publisher_revenue";
+    public static final String KEY_NAME_PUB_REVEUNE_PRECISION = "precision";
+    public static final String KEY_NAME_REV_ID = "revId";
+    public static final String KEY_NAME_SESSION_ID = "sessionId";
+    public static final String KEY_TAPJOY_ANALYTICS_DEVICE_ID = "aId";
+    public static final String KEY_TAPJOY_ANALYTICS_GAME_NAME = "name";
+    public static final String KEY_TAPJOY_REV_ID = "revId";
+    public static final String KEY_TAPJOY_SESSION_ID = "sId";
+    public static final String KEY_TAPJOY_USER_ID = "pId";
+    public static final String KEY_TAPJOY_USER_ID_VERSION = "v";
+    public static final String LOGGING_EXCEPTION_APP_CUSTOM_DATA_FORMAT = "Custom data is not a valid json";
+    public static final String LOGGING_EXCEPTION_GEMS_CUSTOM_DATA_LIMIT = "Overall custom data exceeds 6K size limit";
+    public static final String LOGGING_EXCEPTION_SDK_CUSTOM_DATA_LIMIT = "SDK custom data exceeds 1K size limit";
+    public static final String MAX_TEST_MODE_NETWORK = "test_mode_network";
+    public static final String MEDIATION_CUSTOM_DATA = "customData";
+    public static final String MEDIATION_ENV_DATA = "gemsEnv";
+    public static final String MEDIATION_NETWORK = "mediationNetwork";
+    public static final String MEDIATION_SDK_DATA = "sdkData";
+    public static final String NETWORK = "network";
+    public static final String PLACEMENT_STATUS_CLICKED = "clicked";
+    public static final String PLACEMENT_STATUS_CLOSED = "closed";
+    public static final String PLACEMENT_STATUS_CONTENT_UPDATED = "contentUpdated";
+    public static final String PLACEMENT_STATUS_LOAD_FINISHED = "loadFinished";
+    public static final String PLACEMENT_STATUS_LOAD_STARTED = "loadStarted";
+    public static final String PLACEMENT_STATUS_SHOW_ATTEMPT = "showAttempt";
+    public static final String PLACEMENT_STATUS_SHOW_BLOCKED = "showBlocked";
+    public static final String PLACEMENT_STATUS_SHOW_FINISHED = "showFinished";
+    public static final String PLACEMENT_STATUS_SHOW_STARTED = "showStarted";
+    public static final String SDK_BANNER_POSITION_BOTTOM = "bottom";
+    public static final String SDK_BANNER_POSITION_CENTER = "center";
+    public static final String SDK_BANNER_POSITION_TOP = "top";
+    public static final String SDK_BANNER_SLOT = "bannerSlot";
+    public static final int SDK_CUSTOM_DATA_LIMIT = 1024;
+    public static final String SDK_DISABLED = "disabled";
+    public static final String SDK_FYBER = "fyber";
+    public static final String SDK_GLU_ADS = "gluAds";
+    public static final String SDK_IRONSOURCE_ADQUALITY = "ironSourceAdQuality";
+    public static final String SDK_IRONSOURCE_MEDIATOR = "ironSourceAsMediator";
+    public static final String SDK_MAX = "max";
+    public static final int SDK_MIN_API = 21;
+    public static final String SDK_MOPUB = "moPub";
+    public static final String SDK_PRIVACY_STAGE_ADDED = "added";
+    public static final String SDK_PRIVACY_STAGE_DISABLED = "disabled";
+    public static final String SDK_PRIVACY_STAGE_PREFIX = "privacy.stage.";
+    public static final String SDK_PRIVACY_STAGE_STARTED = "started";
+    public static final String SDK_PRIVACY_STAGE_UNINITIALIZED = "uninitialzed";
+    public static final String SDK_PRIVACY_STAGE_UNSUPPORTED = "unsupported";
+    public static final String SERVED_BY_NETWORK = "servedByAdNetwork";
+    public static final String SINGULAR_AD_REVENUE_REPORT = "singularAdRevenueReport";
+    public static final String STRING_PERIOD = ".";
+    public static final String SUPPRESSION_RULES = "suppressionRules";
+    public static final String VAL_TAPJOY_USER_ID_VERSION = "2";
+    public static final String SDK_ADMOB = "adMob";
+    public static final String SDK_APPLOVIN = "appLovin";
+    public static final String SDK_BIDMACHINE = "bidMachine";
+    public static final String SDK_FACEBOOK_AUDIENCE_NETWORK = "facebookAudienceNetwork";
+    public static final String SDK_IRONSOURCE = "ironSource";
+    public static final String SDK_MINTEGRAL = "mintegral";
+    public static final String SDK_TAPJOY = "tapjoy";
+    public static final String SDK_UNITY_ADS = "unityAds";
+    public static final String SDK_VUNGLE = "vungle";
+    public static final String SDK_ANZU = "anzu";
+    public static final String[] SDK_ARRAY_AD_NETWORKS = {SDK_ADMOB, SDK_APPLOVIN, SDK_BIDMACHINE, "fyber", SDK_FACEBOOK_AUDIENCE_NETWORK, SDK_IRONSOURCE, SDK_MINTEGRAL, SDK_TAPJOY, SDK_UNITY_ADS, SDK_VUNGLE, SDK_ANZU};
+}

decompiled/sources/csdk/gluads/CustomAction.java

@@ -0,0 +1,30 @@
+package csdk.gluads;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.util.ISerializableJsonObject;
+import csdk.gluads.util.JsonUtil;
+import java.util.Map;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class CustomAction implements ISerializableJsonObject {
+
+    @NonNull
+    public final String action;
+
+    @Nullable
+    public final Map<String, Object> extra;
+
+    public CustomAction(String str, Map<String, Object> map) {
+        this.action = str;
+        this.extra = map;
+    }
+
+    @Override // csdk.gluads.util.ISerializableJsonObject
+    public void write(JSONStringer jSONStringer) throws JSONException {
+        JsonUtil.optKeyValue(jSONStringer, "action", this.action);
+        JsonUtil.optKeyValue(jSONStringer, "extra", this.extra);
+    }
+}

decompiled/sources/csdk/gluads/CustomSettings.java

@@ -0,0 +1,9 @@
+package csdk.gluads;
+
+import csdk.gluads.tapjoy.TapjoyConnectState;
+
+/* loaded from: classes4.dex */
+public class CustomSettings {
+    public static CustomSettings DEFAULT = new CustomSettings();
+    public TapjoyConnectState tapjoyConnectState;
+}

decompiled/sources/csdk/gluads/DebugSettings.java

@@ -0,0 +1,7 @@
+package csdk.gluads;
+
+/* loaded from: classes4.dex */
+public class DebugSettings {
+    public static final DebugSettings DEFAULT = new DebugSettings();
+    public boolean isToastEnabled;
+}

decompiled/sources/csdk/gluads/EAAnzu.java

@@ -0,0 +1,89 @@
+package csdk.gluads;
+
+import android.app.Activity;
+import android.content.Context;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import csdk.gluads.impl.AdvertisingImpl;
+import csdk.gluads.impl.DummyAdvertising;
+import csdk.gluads.util.AdvertisingUtil;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.Futures;
+import csdk.gluads.util.IAction1;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+
+/* loaded from: classes4.dex */
+public class EAAnzu {
+    private static Context currentContext = null;
+    private static boolean isAnzuAvailable = false;
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void log(String str) {
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void logNoImpl() {
+        log("Can't find com.anzu.sdk.Anzu");
+    }
+
+    public static Future<?> createAnzu(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @NonNull CustomSettings customSettings, final boolean z, PrivacyStatus privacyStatus, @NonNull AdvertisingImpl advertisingImpl) {
+        Map<String, Object> configDisabled = GluAdsFactory.configDisabled(map);
+        final String string = ConfigUtil.getString(ConfigUtil.configSdk(map), "anzu.appKey");
+        final Activity activity = (Activity) Common.call(callable);
+        if (ConfigUtil.getBoolean(configDisabled, Consts.SDK_ANZU) || TextUtils.isEmpty(string)) {
+            log("createAnzu failed: disabled or app key is missing");
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_ANZU, "disabled", null, advertisingImpl);
+            return GluAdsFactory.disabledFuture();
+        }
+        AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_ANZU, Consts.SDK_PRIVACY_STAGE_ADDED, new IAction1<PrivacyStatus>() { // from class: csdk.gluads.EAAnzu.1
+            @Override // csdk.gluads.util.IAction1
+            public void apply(PrivacyStatus privacyStatus2) {
+                try {
+                    Context applicationContext = activity.getApplicationContext();
+                    if (EAAnzu.currentContext != applicationContext) {
+                        Class.forName("com.anzu.sdk.Anzu").getMethod("SetContext", Context.class).invoke(null, applicationContext);
+                        Context unused = EAAnzu.currentContext = applicationContext;
+                    }
+                    boolean unused2 = EAAnzu.isAnzuAvailable = true;
+                    String packageName = activity.getApplicationContext().getPackageName();
+                    EAAnzu.log("createAnzu: initializing Anzu SDK with appId: " + packageName + " and appKey: " + string);
+                    GluAdsNativeBridge.initAnzuSDK(packageName, string, z, privacyStatus2.gdprApplies, privacyStatus2.hasConsent, privacyStatus2.underAgeUser, privacyStatus2.ccpaApplies, privacyStatus2.ccpaOptOut);
+                } catch (ClassNotFoundException | NoSuchMethodException unused3) {
+                    EAAnzu.logNoImpl();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        }, advertisingImpl);
+        return Futures.successful(Consts.SDK_ANZU);
+    }
+
+    public static void destroyAnzu() {
+        log("destroy");
+        if (isAnzuAvailable) {
+            GluAdsNativeBridge.destroyAnzuSDK();
+        } else {
+            logNoImpl();
+        }
+    }
+
+    public static IAdvertising createNativeAdManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, boolean z) {
+        if (ConfigUtil.getBoolean(ConfigUtil.configDisabled(map), Consts.SDK_ANZU)) {
+            log("createNativeAdManager failed: Anzu is disabled");
+            return new DummyAdvertising();
+        }
+        Map<String, Object> configSdk = ConfigUtil.configSdk(map);
+        String string = ConfigUtil.getString(configSdk, "anzu.urlScheme", "anzu.electronicarts");
+        if (!z) {
+            z = ConfigUtil.getBoolean(configSdk, "debug.anzu", false);
+        }
+        try {
+            return new EAAnzuNativeAdManager(callable, z, string);
+        } catch (Exception unused) {
+            return null;
+        }
+    }
+}

decompiled/sources/csdk/gluads/EAAnzuNativeAdManager.java

@@ -0,0 +1,167 @@
+package csdk.gluads;
+
+import android.app.Activity;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.JsonUtil;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import org.apache.http.cookie.ClientCookie;
+
+/* loaded from: classes4.dex */
+public class EAAnzuNativeAdManager implements IAdvertising {
+    static String bridgeClassName = "csdk.gluads.GluAdsNativeBridge";
+    private final Activity mActivity;
+    private boolean mDebug;
+    private NativeAdListener mListener;
+
+    private void log(String str) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return null;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return true;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    public class NativeAdListener implements IAdvertisingListener {
+        private IAdvertisingListener mListener;
+
+        public NativeAdListener(IAdvertisingListener iAdvertisingListener) {
+            this.mListener = iAdvertisingListener;
+        }
+
+        @Override // csdk.gluads.IAdvertisingListener
+        public void onCustomActionReceived(@NonNull CustomAction customAction) {
+            this.mListener.onCustomActionReceived(customAction);
+        }
+
+        @Override // csdk.gluads.IAdvertisingListener
+        public void onPlacementEvent(@NonNull PlacementEvent placementEvent) {
+            Map createMap = Common.createMap();
+            Map<String, Object> map = placementEvent.extra;
+            if (map != null) {
+                createMap.putAll(map);
+            }
+            createMap.put(Consts.MEDIATION_NETWORK, Consts.SDK_ANZU);
+            this.mListener.onPlacementEvent(new PlacementEvent("nativeAd", placementEvent.placement, placementEvent.status, placementEvent.error, createMap, placementEvent.textureInfo));
+        }
+
+        @Override // csdk.gluads.IAdvertisingListener
+        public void onRewardReceived(@NonNull Reward reward) {
+            this.mListener.onRewardReceived(reward);
+        }
+    }
+
+    public EAAnzuNativeAdManager(Callable<Activity> callable, boolean z, String str) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        this.mActivity = (Activity) Common.call(callable);
+        this.mDebug = z;
+        log("constructor");
+        try {
+            Class.forName(bridgeClassName).getMethod("initNativeAdImpl", Long.TYPE, Boolean.TYPE, String.class).invoke(null, Long.valueOf(GluAdsNativeBridge.getNativeData()), Boolean.valueOf(z), str);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw e;
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("load: ");
+        sb.append(str2);
+        sb.append(" ");
+        sb.append(map != null ? JsonUtil.toJson(map) : "");
+        log(sb.toString());
+        GluAdsNativeBridge.loadNativeAd(GluAdsNativeBridge.getNativeData(), str2, JsonUtil.toJson(map));
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("show:  ");
+        sb.append(str2);
+        sb.append(" ");
+        sb.append(map != null ? map.toString() : "");
+        log(sb.toString());
+        GluAdsNativeBridge.showNativeAd(GluAdsNativeBridge.getNativeData(), str2, JsonUtil.toJson(map));
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+        log("destroy");
+        EAAnzu.destroyAnzu();
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+        log(v8.h.t0);
+        GluAdsNativeBridge.pauseAnzu(GluAdsNativeBridge.getNativeData());
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+        log(v8.h.u0);
+        GluAdsNativeBridge.resumeAnzu(GluAdsNativeBridge.getNativeData());
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        log(ClientCookie.DISCARD_ATTR);
+        GluAdsNativeBridge.discardNativeAd(GluAdsNativeBridge.getNativeData(), str2);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
+        log("setAdvertisingListener");
+        this.mListener = new NativeAdListener(iAdvertisingListener);
+        GluAdsNativeBridge.setListener(GluAdsNativeBridge.getNativeData(), this.mListener);
+    }
+}

decompiled/sources/csdk/gluads/FrequencyController.java

@@ -0,0 +1,318 @@
+package csdk.gluads;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import androidx.annotation.NonNull;
+import com.ironsource.mediationsdk.utils.IronSourceConstants;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes4.dex */
+public class FrequencyController {
+    private static final String AD_TYPE_FREQUENCY_CAP_KEY = "adTypeFrequencyCapKey";
+    private static final String AD_TYPE_FREQUENCY_COUNT_KEY = "adTypeFrequencyCountKey";
+    private static final String AD_TYPE_KEY = "type";
+    private static final String CROSS_PROMO_FREQUENCY_CAP_KEY = "crossPromoFrequencyCapKey";
+    private static final String CROSS_PROMO_FREQUENCY_COUNT_KEY = "crossPromoFrequencyCountKey";
+    private static final String CROSS_PROMO_FREQUENCY_SESSION_KEY = "crossPromoFrequencySessionKey";
+    private static final String FREQUENCY_CAP = "cap";
+    private static final String FREQUENCY_CAP_KEY = "frequencyCapKey";
+    private static final String FREQUENCY_COUNT_KEY = "frequencyCountKey";
+    private static final String FREQUENCY_RESET_TIMESTAMP = "resetTimeStamp";
+    private static final String FREQUENCY_SESSION = "session";
+    private static final String FREQUENCY_SESSION_KEY = "frequencySessionKey";
+    private static final String FREQUENCY_SPACING = "spacing";
+    private static final String FREQUENCY_TIMESTAMP = "timestamp";
+    private static final String SHARED_PREFS_NAME = "gluFrequency";
+    private Map<String, Object> mAdTypeFrequencyCapCache;
+    private Map<String, Object> mAdTypeFrequencyCountCache;
+    private final String mAdvertisementType;
+    private Map<String, Object> mCrossPromoFrequencyCapCache;
+    private Map<String, Object> mCrossPromoFrequencyCountCache;
+    private Map<String, Object> mCrossPromoFrequencySessionCache;
+    private Map<String, Object> mFrequencyCapCache;
+    private Map<String, Object> mFrequencyCountCache;
+    private Map<String, Object> mFrequencySessionCache;
+    private long mLastRulesRefreshRequestTS;
+    private final SharedPreferences mSharedPrefs;
+    private boolean mShouldIgnoreGlobalFreqCapping;
+    private Map<String, Object> mShowCount;
+
+    private static void log(String str) {
+    }
+
+    public void enableGlobalFrequencyCapping() {
+        this.mShouldIgnoreGlobalFreqCapping = false;
+    }
+
+    public FrequencyController(String str, Context context, Map<String, Object> map) {
+        this.mAdvertisementType = str;
+        SharedPreferences sharedPreferences = context.getSharedPreferences(getSharedPrefsNameByAdType(str, SHARED_PREFS_NAME), 0);
+        this.mSharedPrefs = sharedPreferences;
+        this.mFrequencyCountCache = Common.loadMap(sharedPreferences, FREQUENCY_COUNT_KEY);
+        this.mFrequencyCapCache = Common.loadMap(sharedPreferences, FREQUENCY_CAP_KEY);
+        this.mFrequencySessionCache = Common.loadMap(sharedPreferences, FREQUENCY_SESSION_KEY);
+        if (map != null && this.mFrequencyCapCache.size() == 0) {
+            this.mFrequencyCapCache = ConfigUtil.getMap(map, str, Collections.EMPTY_MAP);
+        }
+        this.mCrossPromoFrequencyCountCache = Common.loadMap(sharedPreferences, CROSS_PROMO_FREQUENCY_COUNT_KEY);
+        this.mCrossPromoFrequencyCapCache = Common.loadMap(sharedPreferences, CROSS_PROMO_FREQUENCY_CAP_KEY);
+        this.mCrossPromoFrequencySessionCache = Common.loadMap(sharedPreferences, CROSS_PROMO_FREQUENCY_SESSION_KEY);
+        this.mShowCount = new ConcurrentHashMap();
+        this.mAdTypeFrequencyCountCache = Common.loadMap(sharedPreferences, AD_TYPE_FREQUENCY_COUNT_KEY);
+        Map<String, Object> loadMap = Common.loadMap(sharedPreferences, AD_TYPE_FREQUENCY_CAP_KEY);
+        this.mAdTypeFrequencyCapCache = loadMap;
+        if (map != null && loadMap.size() == 0) {
+            this.mAdTypeFrequencyCapCache = ConfigUtil.getMap(map, "type", Collections.EMPTY_MAP);
+        }
+        this.mShouldIgnoreGlobalFreqCapping = true;
+        this.mLastRulesRefreshRequestTS = 0L;
+    }
+
+    private boolean internal_isLimitReached(@NonNull String str) {
+        boolean z;
+        synchronized (this.mSharedPrefs) {
+            long longValue = getLongValue(this.mFrequencyCountCache, str);
+            long longValue2 = getLongValue(this.mFrequencyCapCache.get(str), FREQUENCY_CAP);
+            z = longValue2 > 0 && longValue >= longValue2;
+        }
+        return z;
+    }
+
+    private boolean internal_isLimitReachedForAdType() {
+        boolean z;
+        synchronized (this.mSharedPrefs) {
+            long longValue = getLongValue(this.mAdTypeFrequencyCountCache, this.mAdvertisementType);
+            long longValue2 = getLongValue(this.mAdTypeFrequencyCapCache.get(this.mAdvertisementType), FREQUENCY_CAP);
+            z = longValue2 > 0 && longValue >= longValue2;
+        }
+        return z;
+    }
+
+    public boolean isLimitReached(@NonNull String str) {
+        return (!this.mShouldIgnoreGlobalFreqCapping && internal_isLimitReachedForAdType()) || internal_isLimitReached(str);
+    }
+
+    public boolean shouldShowCrossPromo(@NonNull String str) {
+        synchronized (this.mSharedPrefs) {
+            try {
+                long longValue = getLongValue(this.mShowCount, str);
+                long longValue2 = getLongValue(this.mCrossPromoFrequencyCapCache.get(str), FREQUENCY_SPACING);
+                if (longValue2 != 0 && longValue % (1 + longValue2) != longValue2) {
+                    return false;
+                }
+                long longValue3 = getLongValue(this.mCrossPromoFrequencyCountCache, str);
+                long longValue4 = getLongValue(this.mCrossPromoFrequencyCapCache.get(str), FREQUENCY_CAP);
+                return longValue4 == 0 || longValue3 < longValue4;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void onNewSession() {
+        synchronized (this.mSharedPrefs) {
+            try {
+                boolean z = false;
+                if (this.mFrequencyCapCache.size() > 0) {
+                    boolean z2 = false;
+                    for (Map.Entry<String, Object> entry : this.mFrequencyCapCache.entrySet()) {
+                        String key = entry.getKey();
+                        long longValue = getLongValue(entry.getValue(), FREQUENCY_SESSION);
+                        if (longValue > 0) {
+                            long longValue2 = getLongValue(this.mFrequencySessionCache, key);
+                            if (longValue2 < longValue) {
+                                this.mFrequencySessionCache.put(key, Long.valueOf(longValue2 + 1));
+                            } else {
+                                this.mFrequencySessionCache.remove(key);
+                                if (this.mFrequencyCountCache.containsKey(key)) {
+                                    this.mFrequencyCountCache.remove(key);
+                                    Common.saveMap(this.mSharedPrefs, FREQUENCY_COUNT_KEY, this.mFrequencyCountCache);
+                                }
+                            }
+                            z2 = true;
+                        }
+                    }
+                    if (z2) {
+                        Common.saveMap(this.mSharedPrefs, FREQUENCY_SESSION_KEY, this.mFrequencySessionCache);
+                    }
+                }
+                if (this.mCrossPromoFrequencyCapCache.size() > 0) {
+                    for (Map.Entry<String, Object> entry2 : this.mCrossPromoFrequencyCapCache.entrySet()) {
+                        String key2 = entry2.getKey();
+                        long longValue3 = getLongValue(entry2.getValue(), FREQUENCY_SESSION);
+                        if (longValue3 > 0) {
+                            long longValue4 = getLongValue(this.mCrossPromoFrequencySessionCache, key2);
+                            if (longValue4 < longValue3) {
+                                this.mCrossPromoFrequencySessionCache.put(key2, Long.valueOf(longValue4 + 1));
+                            } else {
+                                this.mCrossPromoFrequencySessionCache.remove(key2);
+                                if (this.mCrossPromoFrequencyCountCache.containsKey(key2)) {
+                                    this.mCrossPromoFrequencyCountCache.remove(key2);
+                                    Common.saveMap(this.mSharedPrefs, CROSS_PROMO_FREQUENCY_COUNT_KEY, this.mCrossPromoFrequencyCountCache);
+                                }
+                            }
+                            z = true;
+                        }
+                    }
+                    if (z) {
+                        Common.saveMap(this.mSharedPrefs, CROSS_PROMO_FREQUENCY_SESSION_KEY, this.mCrossPromoFrequencySessionCache);
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void update(@NonNull Map<String, Object> map) {
+        boolean z;
+        synchronized (this.mSharedPrefs) {
+            try {
+                Map<String, Object> map2 = ConfigUtil.getMap(map, this.mAdvertisementType, Collections.EMPTY_MAP);
+                if (map2.isEmpty()) {
+                    this.mFrequencyCountCache.clear();
+                    this.mFrequencyCapCache.clear();
+                    Common.saveMap(this.mSharedPrefs, FREQUENCY_COUNT_KEY, this.mFrequencyCountCache);
+                    Common.saveMap(this.mSharedPrefs, FREQUENCY_CAP_KEY, this.mFrequencyCapCache);
+                } else {
+                    Map<String, Object> createMap = Common.createMap();
+                    createMap.putAll(map2);
+                    for (Map.Entry<String, Object> entry : createMap.entrySet()) {
+                        String key = entry.getKey();
+                        if (getLongValue(entry.getValue(), FREQUENCY_SESSION) > 0 || getLongValue(entry.getValue(), "timestamp") == getLongValue(this.mFrequencyCapCache.get(key), "timestamp")) {
+                            z = false;
+                        } else {
+                            if (this.mFrequencyCountCache.containsKey(key)) {
+                                this.mFrequencyCountCache.remove(key);
+                                Common.saveMap(this.mSharedPrefs, FREQUENCY_COUNT_KEY, this.mFrequencyCountCache);
+                            }
+                            z = true;
+                        }
+                        Map map3 = (Map) Common.get((Map) entry.getValue(), "crossPromo");
+                        if (map3 != null) {
+                            if ((getLongValue(map3, FREQUENCY_SESSION) <= 0 || z) && ((getLongValue(map3, "timestamp") != getLongValue(this.mCrossPromoFrequencyCapCache.get(key), "timestamp") || z) && this.mCrossPromoFrequencyCountCache.containsKey(key))) {
+                                this.mCrossPromoFrequencyCountCache.remove(key);
+                                Common.saveMap(this.mSharedPrefs, CROSS_PROMO_FREQUENCY_COUNT_KEY, this.mCrossPromoFrequencyCountCache);
+                            }
+                            this.mCrossPromoFrequencyCapCache.put(key, map3);
+                        }
+                    }
+                    this.mFrequencyCapCache = createMap;
+                    Common.saveMap(this.mSharedPrefs, FREQUENCY_CAP_KEY, createMap);
+                    Common.saveMap(this.mSharedPrefs, CROSS_PROMO_FREQUENCY_CAP_KEY, this.mCrossPromoFrequencyCapCache);
+                }
+                Map<String, Object> map4 = ConfigUtil.getMap(map, "type", Collections.EMPTY_MAP);
+                if (map4.isEmpty()) {
+                    this.mAdTypeFrequencyCountCache.clear();
+                    this.mAdTypeFrequencyCapCache.clear();
+                    Common.saveMap(this.mSharedPrefs, AD_TYPE_FREQUENCY_COUNT_KEY, this.mAdTypeFrequencyCountCache);
+                    Common.saveMap(this.mSharedPrefs, AD_TYPE_FREQUENCY_CAP_KEY, this.mAdTypeFrequencyCapCache);
+                } else {
+                    Map createMap2 = Common.createMap();
+                    createMap2.putAll(map4);
+                    for (Map.Entry entry2 : createMap2.entrySet()) {
+                        String str = (String) entry2.getKey();
+                        if (str.equals(this.mAdvertisementType) && getLongValue(entry2.getValue(), FREQUENCY_SESSION) <= 0 && getLongValue(entry2.getValue(), FREQUENCY_RESET_TIMESTAMP) != getLongValue(this.mAdTypeFrequencyCapCache.get(str), FREQUENCY_RESET_TIMESTAMP) && this.mAdTypeFrequencyCountCache.containsKey(str)) {
+                            this.mAdTypeFrequencyCountCache.remove(str);
+                            Common.saveMap(this.mSharedPrefs, AD_TYPE_FREQUENCY_COUNT_KEY, this.mAdTypeFrequencyCountCache);
+                        }
+                    }
+                    this.mAdTypeFrequencyCapCache = map4;
+                    Common.saveMap(this.mSharedPrefs, AD_TYPE_FREQUENCY_CAP_KEY, map4);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public long getCurrentServerTime() {
+        return System.currentTimeMillis() / 1000;
+    }
+
+    private boolean internal_isFreqCountRefreshRequiredForAdType() {
+        long longValue = getLongValue(this.mAdTypeFrequencyCapCache.get(this.mAdvertisementType), FREQUENCY_RESET_TIMESTAMP);
+        if (longValue <= 0) {
+            return false;
+        }
+        long currentServerTime = getCurrentServerTime();
+        if (currentServerTime <= longValue || this.mLastRulesRefreshRequestTS >= currentServerTime) {
+            return false;
+        }
+        this.mLastRulesRefreshRequestTS = currentServerTime + ConfigUtil.getLong(this.mAdTypeFrequencyCapCache.get(this.mAdvertisementType), "minTimeToNextRefreshInSeconds", 60L);
+        return true;
+    }
+
+    public boolean isFreqCountRefreshRequired(@NonNull String str) {
+        return !this.mShouldIgnoreGlobalFreqCapping && internal_isFreqCountRefreshRequiredForAdType();
+    }
+
+    private void internal_increaseCount(boolean z, @NonNull String str) {
+        synchronized (this.mSharedPrefs) {
+            try {
+                long longValue = getLongValue(this.mFrequencyCountCache, str);
+                long longValue2 = getLongValue(this.mFrequencyCapCache.get(str), FREQUENCY_CAP);
+                if (longValue2 != 0 && longValue < longValue2) {
+                    this.mFrequencyCountCache.put(str, Long.valueOf(longValue + 1));
+                    Common.saveMap(this.mSharedPrefs, FREQUENCY_COUNT_KEY, this.mFrequencyCountCache);
+                }
+                if (z) {
+                    long longValue3 = getLongValue(this.mCrossPromoFrequencyCountCache, str);
+                    long longValue4 = getLongValue(this.mCrossPromoFrequencyCapCache.get(str), FREQUENCY_CAP);
+                    if (longValue4 != 0 && longValue3 < longValue4) {
+                        this.mCrossPromoFrequencyCountCache.put(str, Long.valueOf(longValue3 + 1));
+                        Common.saveMap(this.mSharedPrefs, CROSS_PROMO_FREQUENCY_COUNT_KEY, this.mCrossPromoFrequencyCountCache);
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        Map<String, Object> map = this.mShowCount;
+        map.put(str, Long.valueOf(getLongValue(map, str) + 1));
+    }
+
+    private void internal_increaseCountForAdType() {
+        synchronized (this.mSharedPrefs) {
+            try {
+                long longValue = getLongValue(this.mAdTypeFrequencyCountCache, this.mAdvertisementType);
+                long longValue2 = getLongValue(this.mAdTypeFrequencyCapCache.get(this.mAdvertisementType), FREQUENCY_CAP);
+                if (longValue2 != 0 && longValue < longValue2) {
+                    this.mAdTypeFrequencyCountCache.put(this.mAdvertisementType, Long.valueOf(longValue + 1));
+                    Common.saveMap(this.mSharedPrefs, AD_TYPE_FREQUENCY_COUNT_KEY, this.mAdTypeFrequencyCountCache);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void increaseCount(boolean z, @NonNull String str) {
+        if (!this.mShouldIgnoreGlobalFreqCapping) {
+            internal_increaseCountForAdType();
+        }
+        internal_increaseCount(z, str);
+    }
+
+    private static long getLongValue(Object obj, String str) {
+        Object obj2;
+        if (str == null || obj == null || !(obj instanceof Map) || (obj2 = ((Map) obj).get(str)) == null || !(obj2 instanceof Number)) {
+            return 0L;
+        }
+        return ((Number) obj2).longValue();
+    }
+
+    private static String getSharedPrefsNameByAdType(@NonNull String str, @NonNull String str2) {
+        if (str.equals("interstitial")) {
+            return str2 + "INT";
+        }
+        if (!str.equals(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
+            return str2;
+        }
+        return str2 + IronSourceConstants.REWARDED_VIDEO_EVENT_TYPE;
+    }
+}

decompiled/sources/csdk/gluads/GemsDataUtil.java

@@ -0,0 +1,79 @@
+package csdk.gluads;
+
+import android.text.TextUtils;
+import android.util.Base64;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.JsonUtil;
+import csdk.gluads.util.log.YLogger;
+import java.nio.charset.Charset;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class GemsDataUtil {
+    public static final String PLAYER_ID = "playerId";
+
+    public static String base64Encode(@Nullable String str) {
+        return TextUtils.isEmpty(str) ? str : Base64.encodeToString(str.getBytes(Charset.forName("UTF-8")), 2).trim();
+    }
+
+    public static String gemsPlayerIDEncoded(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return str;
+        }
+        try {
+            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
+            Map createMap = Common.createMap();
+            if (parseJsonObject != null && parseJsonObject.containsKey("playerId")) {
+                createMap.put("playerId", parseJsonObject.get("playerId"));
+            }
+            return base64EncodeMap(createMap);
+        } catch (Throwable unused) {
+            return str;
+        }
+    }
+
+    public static Map<String, Object> gemsCustomData(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
+            if (parseJsonObject != null) {
+                parseJsonObject.remove("playerId");
+            }
+            return parseJsonObject;
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    public static String buildSplitIDCustomData(@Nullable String str, @NonNull Map<String, Object> map, @NonNull String str2, @NonNull YLogger yLogger) {
+        Map createMap = Common.createMap();
+        String base64EncodeMap = base64EncodeMap(map);
+        if (base64EncodeMap.length() <= 1024) {
+            createMap.put(Consts.MEDIATION_SDK_DATA, base64EncodeMap);
+        } else {
+            yLogger.e("REWARDED_INTERSTITIAL.CUSTOM.DATA.ERROR", "l", str2, InneractiveMediationDefs.GENDER_MALE, Consts.LOGGING_EXCEPTION_SDK_CUSTOM_DATA_LIMIT);
+        }
+        if (!TextUtils.isEmpty(str)) {
+            if (base64EncodeMap.length() + str.length() <= 6144) {
+                try {
+                    JsonUtil.parseJsonObject(str);
+                    createMap.put(Consts.MEDIATION_CUSTOM_DATA, str);
+                } catch (Throwable unused) {
+                    yLogger.e("REWARDED_INTERSTITIAL.CUSTOM.DATA.ERROR", "l", str2, InneractiveMediationDefs.GENDER_MALE, Consts.LOGGING_EXCEPTION_APP_CUSTOM_DATA_FORMAT);
+                }
+            } else {
+                yLogger.e("REWARDED_INTERSTITIAL.CUSTOM.DATA.ERROR", "l", str2, InneractiveMediationDefs.GENDER_MALE, Consts.LOGGING_EXCEPTION_GEMS_CUSTOM_DATA_LIMIT);
+            }
+        }
+        return JsonUtil.toJson(createMap);
+    }
+
+    public static String base64EncodeMap(@Nullable Map<String, Object> map) {
+        return map == null ? "" : base64Encode(JsonUtil.toJson(map));
+    }
+}

decompiled/sources/csdk/gluads/GluAdsFactory.java

@@ -0,0 +1,507 @@
+package csdk.gluads;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Build;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.ProxyConfig;
+import com.facebook.share.internal.ShareConstants;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.glu.plugins.gluanalytics.AnalyticsData;
+import com.ironsource.b4;
+import com.mbridge.msdk.foundation.same.report.i;
+import com.tapjoy.TJConnectListener;
+import com.tapjoy.TJPrivacyPolicy;
+import com.tapjoy.TJStatus;
+import com.tapjoy.Tapjoy;
+import com.tapjoy.TapjoyConnectFlag;
+import csdk.gluads.eventbus.ConfigGetterEventHandler;
+import csdk.gluads.eventbus.GluAdsEventHandler;
+import csdk.gluads.eventbus.GluEventBus;
+import csdk.gluads.impl.AdvertisingImpl;
+import csdk.gluads.impl.AdvertisingProxy;
+import csdk.gluads.impl.DisabledException;
+import csdk.gluads.impl.DummyAdvertising;
+import csdk.gluads.impl.IllegalConfigurationException;
+import csdk.gluads.impl.QueuingAdvertising;
+import csdk.gluads.impl.SuppressionRulesProxy;
+import csdk.gluads.ironsource.EAIronSource;
+import csdk.gluads.max.EAMax;
+import csdk.gluads.tapjoy.TapjoyConnectState;
+import csdk.gluads.tapjoy.TapjoyOfferWallManager;
+import csdk.gluads.util.AdvertisingUtil;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.DeviceUtil;
+import csdk.gluads.util.Futures;
+import csdk.gluads.util.IAction1;
+import csdk.gluads.util.IAction2;
+import csdk.gluads.util.JsonUtil;
+import csdk.gluads.util.broadcastmanager.DummyBroadcastManger;
+import csdk.gluads.util.broadcastmanager.GluBroadcastManager;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import csdk.gluads.util.log.YLoggers;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class GluAdsFactory {
+    private static final String CONSENT_NO = "0";
+    private static final String CONSENT_YES = "1";
+    private List<AdvertisingProxy> mProxies = null;
+    private final YLogger log = YLoggerFactory.getLogger(getClass());
+
+    @Nullable
+    private static Map<String, Object> configSdk(@NonNull Map<String, Object> map) {
+        return ConfigUtil.configSdk(map);
+    }
+
+    @Nullable
+    private static Map<String, Object> configComponents(@NonNull Map<String, Object> map) {
+        return ConfigUtil.configComponents(map);
+    }
+
+    @Nullable
+    public static Map<String, Object> configDisabled(@NonNull Map<String, Object> map) {
+        return ConfigUtil.configDisabled(map);
+    }
+
+    @NonNull
+    public static Future<?> disabledFuture() {
+        return Futures.failed(new DisabledException());
+    }
+
+    private static boolean isComponentDisabled(@NonNull Map<String, Object> map, @NonNull String str, @NonNull String str2) {
+        String str3;
+        StringBuilder sb = new StringBuilder();
+        sb.append(str);
+        if (str2 == null || str2.length() <= 0) {
+            str3 = "";
+        } else {
+            str3 = str2.substring(0, 1).toUpperCase(Locale.US) + str2.substring(1);
+        }
+        sb.append(str3);
+        String sb2 = sb.toString();
+        Map<String, Object> configDisabled = configDisabled(map);
+        return ConfigUtil.getBoolean(configDisabled, str) || ConfigUtil.getBoolean(configDisabled, sb2);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void putIfNotNull(Map<String, IAdvertising> map, String str, IAdvertising iAdvertising) {
+        if (iAdvertising != null) {
+            map.put(str, iAdvertising);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static List<AdvertisingProxy> createProxies(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @NonNull Long l) {
+        return Arrays.asList(new SuppressionRulesProxy(callable, map, l.longValue()));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static IAdvertising wireProxies(IAdvertising iAdvertising, List<AdvertisingProxy> list) {
+        int size = list.size() - 1;
+        while (size >= 0) {
+            AdvertisingProxy advertisingProxy = list.get(size);
+            advertisingProxy.init(iAdvertising);
+            size--;
+            iAdvertising = advertisingProxy;
+        }
+        return iAdvertising;
+    }
+
+    private static GluEventBus eventBus(Map<String, Object> map) {
+        return ConfigUtil.getBoolean(map, "csdk.gluAds.disabled.eventBus", false) ? GluEventBus.DISCONNECTED : GluEventBus.SHARED;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static List<String> componentTypes() {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL);
+        arrayList.add("interstitial");
+        arrayList.add(Consts.ADVERTISEMENT_TYPE_OFFER_WALL);
+        arrayList.add("banner");
+        return arrayList;
+    }
+
+    @NonNull
+    public IAdvertising createAdvertising(@NonNull final Callable<Activity> callable, @NonNull String str, @Nullable Map<String, Object> map) {
+        YLoggers.sdkVersion(this.log, Consts.SDK_GLU_ADS, BuildConfig.VERSION_NAME);
+        Common.require(callable != null, "activityGetter can't be null.");
+        Common.require(str != null, "jsonConfig can't be null.");
+        this.mProxies = null;
+        final long currentTimeMillis = System.currentTimeMillis();
+        final Map shallowClone = Common.shallowClone(map);
+        final QueuingAdvertising queuingAdvertising = new QueuingAdvertising();
+        IAction2<String, String> iAction2 = new IAction2<String, String>() { // from class: csdk.gluads.GluAdsFactory.1
+            @Override // csdk.gluads.util.IAction2
+            public void apply(final String str2, String str3) {
+                YLogger yLogger = GluAdsFactory.this.log;
+                Object[] objArr = new Object[4];
+                objArr[0] = "sdk";
+                objArr[1] = Consts.SDK_GLU_ADS;
+                objArr[2] = ShareConstants.FEED_SOURCE_PARAM;
+                objArr[3] = str3 != null ? str3.toUpperCase(Locale.US) : null;
+                yLogger.d("CONFIG.RECONFIGURE", objArr);
+                new Thread() { // from class: csdk.gluads.GluAdsFactory.1.1
+                    @Override // java.lang.Thread, java.lang.Runnable
+                    public void run() {
+                        try {
+                            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str2);
+                            AnonymousClass1 anonymousClass1 = AnonymousClass1.this;
+                            GluAdsFactory.this.doCreateQueuingAdvertising(queuingAdvertising, callable, parseJsonObject, shallowClone, currentTimeMillis);
+                        } catch (JSONException e) {
+                            throw Common.propagate(e);
+                        }
+                    }
+                }.start();
+            }
+        };
+        try {
+            final Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
+            String json = JsonUtil.toJson(parseJsonObject);
+            boolean z = ConfigUtil.getBoolean(parseJsonObject, "csdk.gluAds.disabled.configUpdate", false);
+            long j = (long) (ConfigUtil.getDouble(parseJsonObject, "csdk.gluAds.configUpdate.timeoutInSec", 5.0d) * 1000.0d);
+            GluEventBus eventBus = eventBus(parseJsonObject);
+            if (eventBus.isConnected() && !z) {
+                ConfigGetterEventHandler.subscribe(eventBus, GluEventBus.GLOBAL_TOKEN, iAction2, json).requestConfig(j);
+            } else {
+                this.log.d("CONFIG.RECONFIGURE", "sdk", Consts.SDK_GLU_ADS, ShareConstants.FEED_SOURCE_PARAM, "APP-NO-EB");
+                new Thread() { // from class: csdk.gluads.GluAdsFactory.2
+                    @Override // java.lang.Thread, java.lang.Runnable
+                    public void run() {
+                        GluAdsFactory.this.doCreateQueuingAdvertising(queuingAdvertising, callable, parseJsonObject, shallowClone, currentTimeMillis);
+                    }
+                }.start();
+            }
+            return queuingAdvertising;
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void doCreateQueuingAdvertising(@NonNull QueuingAdvertising queuingAdvertising, @NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, long j) {
+        try {
+            queuingAdvertising.delegateTo(doCreateAdvertising(callable, map, map2, j));
+        } catch (RuntimeException e) {
+            queuingAdvertising.destroy();
+            throw Common.propagate(e);
+        }
+    }
+
+    private IAdvertising doCreateAdvertising(@NonNull final Callable<Activity> callable, @NonNull final Map<String, Object> map, @Nullable final Map<String, Object> map2, final long j) {
+        if (ConfigUtil.getBoolean(map, "csdk.disabled.gluAds")) {
+            YLoggers.sdkConfiguration(this.log, Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
+            return new DummyAdvertising();
+        }
+        if (!AdvertisingUtil.isAPIEnabled()) {
+            YLoggers.sdkConfiguration(this.log, Consts.SDK_GLU_ADS, "DISABLE", "API", Consts.KEY_TAPJOY_USER_ID_VERSION, Integer.valueOf(Build.VERSION.SDK_INT));
+            return new DummyAdvertising();
+        }
+        final Context applicationContext = ((Activity) Common.call(callable)).getApplicationContext();
+        final boolean isTablet = DeviceUtil.isTablet(applicationContext);
+        final KillSwitch killSwitch = new KillSwitch();
+        final DebugSettings debugSettings = new DebugSettings();
+        debugSettings.isToastEnabled = ConfigUtil.getBoolean(configSdk(map), "debug.all");
+        if (ConfigUtil.getBoolean(configSdk(map), "disabled.callTracking", false)) {
+            GluAdsNativeBridge.disableCallTracking();
+        }
+        final CustomSettings customSettings = new CustomSettings();
+        final AdvertisingImpl advertisingImpl = new AdvertisingImpl(GluBroadcastManager.isSupported() ? GluBroadcastManager.getInstance(((Activity) Common.call(callable)).getApplicationContext()) : DummyBroadcastManger.INSTANCE, applicationContext);
+        boolean z = !ConfigUtil.getBoolean(configSdk(map), "disabled.privacyFlagsInRTConfig", true);
+        final boolean z2 = ConfigUtil.getBoolean(configSdk(map), "disabled.ironSourceAsMediator", false);
+        PrivacyStatus privacyStatus = z ? new PrivacyStatus(ConfigUtil.getBoolean(map2, PrivacyStatus.GDPR_APPLIES, false), ConfigUtil.getBoolean(map2, PrivacyStatus.HAS_CONSENT, true), ConfigUtil.getBoolean(map2, PrivacyStatus.CCPA_APPLIES, false), ConfigUtil.getBoolean(map2, PrivacyStatus.CCPA_OPT_OUT, false), ConfigUtil.getBoolean(map2, PrivacyStatus.UNDER_AGE_USER, false), ConfigUtil.getBoolean(map2, PrivacyStatus.TEEN_USER, false)) : null;
+        final LoadingScreen loadingScreen = new LoadingScreen();
+        boolean z3 = !ConfigUtil.getBoolean(configSdk(map), "disabled.offerWallLoadingIndicator", false);
+        if (z3) {
+            Common.runOnUIThread(new FutureTask(new Callable<Object>() { // from class: csdk.gluads.GluAdsFactory.3
+                @Override // java.util.concurrent.Callable
+                public Object call() throws Exception {
+                    try {
+                        loadingScreen.initialize(callable);
+                        return null;
+                    } catch (Throwable th) {
+                        YLoggers.sdkConfigurationError(GluAdsFactory.this.log, Consts.ADVERTISEMENT_TYPE_OFFER_WALL, "l", Consts.SDK_GLU_ADS, "e", th);
+                        throw th;
+                    }
+                }
+            }));
+        }
+        boolean z4 = z3 && !ConfigUtil.getBoolean(configSdk(map), "disabled.inAppMessageAdLoadingIndicator", false);
+        final Map<String, Object> configComponents = configComponents(map);
+        PrivacyStatus privacyStatus2 = privacyStatus;
+        IAction1<PrivacyStatus> iAction1 = new IAction1<PrivacyStatus>() { // from class: csdk.gluads.GluAdsFactory.4
+            /* JADX WARN: Code restructure failed: missing block: B:19:0x0046, code lost:
+            
+                if (r26.underAgeUser == false) goto L19;
+             */
+            /* JADX WARN: Code restructure failed: missing block: B:21:0x004a, code lost:
+            
+                if (r26.teenUser != false) goto L22;
+             */
+            /* JADX WARN: Code restructure failed: missing block: B:47:0x004c, code lost:
+            
+                r3 = true;
+             */
+            @Override // csdk.gluads.util.IAction1
+            /*
+                Code decompiled incorrectly, please refer to instructions dump.
+                To view partially-correct add '--show-bad-code' argument
+            */
+            public void apply(csdk.gluads.PrivacyStatus r26) {
+                /*
+                    Method dump skipped, instructions count: 575
+                    To view this dump add '--comments-level debug' option
+                */
+                throw new UnsupportedOperationException("Method not decompiled: csdk.gluads.GluAdsFactory.AnonymousClass4.apply(csdk.gluads.PrivacyStatus):void");
+            }
+        };
+        for (String str : Consts.SDK_ARRAY_AD_NETWORKS) {
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(applicationContext, str, "disabled", iAction1, advertisingImpl);
+        }
+        Map<String, IAdvertising> createMap = Common.createMap();
+        advertisingImpl.setComponentHandlers(createMap);
+        YLoggers.sdkConfiguration(this.log, Consts.SDK_GLU_ADS, "handlers", createMap.keySet());
+        String string = ConfigUtil.getString(configComponents(map), Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL);
+        Map map3 = Collections.EMPTY_MAP;
+        final Map<String, Object> map4 = ConfigUtil.getMap(configSdk(map), string + ".rewards", map3);
+        final Map<String, Object> map5 = ConfigUtil.getMap(configSdk(map), "frequency", map3);
+        final GluAdsEventHandler subscribe = GluAdsEventHandler.subscribe(eventBus(map), GluEventBus.GLOBAL_TOKEN, advertisingImpl);
+        if (!ConfigUtil.getBoolean(map, "csdk.gluAds.disabled.autoFetchRulesTagOnShow", false)) {
+            subscribe.enableAutoRulesTagFetchOnShow();
+        }
+        if (!ConfigUtil.getBoolean(map, "csdk.gluAds.disabled.xpv2ImpressionMapping", false)) {
+            subscribe.enableImpressionMapping();
+        }
+        final boolean z5 = z4;
+        advertisingImpl.initialize(new Runnable() { // from class: csdk.gluads.GluAdsFactory.5
+            @Override // java.lang.Runnable
+            public void run() {
+                subscribe.onInit(BuildConfig.VERSION_NAME, z5 ? loadingScreen : null);
+                subscribe.requestRewardConfig(JsonUtil.toJson(map4));
+                subscribe.requestRulesConfig(JsonUtil.toJson(map5), null);
+            }
+        }, new Runnable() { // from class: csdk.gluads.GluAdsFactory.6
+            @Override // java.lang.Runnable
+            public void run() {
+                subscribe.onDestroy();
+            }
+        }, subscribe);
+        if (z) {
+            advertisingImpl.internal_updatePrivacyStatus(privacyStatus2);
+        }
+        boolean z6 = !ConfigUtil.getBoolean(map, "csdk.gluAds.disabled.setUIDFromRTConf", true);
+        String string2 = ConfigUtil.getString(map2, AnalyticsData.S_USER_ID);
+        if (z6 && string2 != null) {
+            advertisingImpl.setUserIdentifier(string2, null);
+        }
+        if (this.mProxies == null) {
+            this.mProxies = createProxies(callable, map, Long.valueOf(j));
+        }
+        return wireProxies(advertisingImpl, this.mProxies);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @Nullable
+    public IAdvertising createInterstitialOrDie(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @NonNull KillSwitch killSwitch, @NonNull DebugSettings debugSettings, boolean z, @Nullable CustomSettings customSettings, PrivacyStatus privacyStatus) {
+        GluEventBus gluEventBus = null;
+        if (privacyStatus == null) {
+            this.log.d("Can't create Interstitial component since the privacy status is null", new Object[0]);
+            return null;
+        }
+        String string = ConfigUtil.getString(configComponents(map), "interstitial");
+        if (TextUtils.isEmpty(string)) {
+            YLoggers.componentConfiguration(this.log, "interstitial", "enabled", Boolean.FALSE);
+            return null;
+        }
+        if (TextUtils.equals(string, Consts.SDK_IRONSOURCE) || privacyStatus.underAgeUser || privacyStatus.teenUser) {
+            if (isComponentDisabled(map, Consts.SDK_IRONSOURCE, "interstitial")) {
+                throw new IllegalConfigurationException("IronSource is disabled.");
+            }
+            return EAIronSource.createIronSourceInterstitialManager(callable, map, z);
+        }
+        if (TextUtils.equals(string, "max") || TextUtils.equals(string, Consts.SDK_APPLOVIN) || TextUtils.equals(string, Consts.SDK_MOPUB)) {
+            if (isComponentDisabled(map, "max", "interstitial")) {
+                throw new IllegalConfigurationException("max is disabled.");
+            }
+            GluEventBus eventBus = eventBus(map);
+            if (eventBus != GluEventBus.DISCONNECTED && !ConfigUtil.getBoolean(configDisabled(map), "rewardedInterstitialCrossPromoBlocked", false)) {
+                gluEventBus = eventBus;
+            }
+            return EAMax.createInterstitialManager(callable, map, z, gluEventBus);
+        }
+        YLoggers.componentConfiguration(this.log, "interstitial", "l", Consts.SDK_GLU_ADS, i.a, "unsupportedType", Consts.KEY_TAPJOY_USER_ID_VERSION, string);
+        return null;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @Nullable
+    public IAdvertising createRewardedInterstitialOrDie(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @NonNull KillSwitch killSwitch, @NonNull DebugSettings debugSettings, boolean z, @NonNull CustomSettings customSettings, PrivacyStatus privacyStatus) {
+        GluEventBus gluEventBus = null;
+        if (privacyStatus == null) {
+            this.log.d("Can't create rewarded interstitial component since the privacy status is null", new Object[0]);
+            return null;
+        }
+        String string = ConfigUtil.getString(configComponents(map), Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL);
+        if (TextUtils.isEmpty(string)) {
+            YLoggers.componentConfiguration(this.log, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, "enabled", Boolean.FALSE);
+            return null;
+        }
+        if (TextUtils.equals(string, Consts.SDK_IRONSOURCE) || privacyStatus.underAgeUser || privacyStatus.teenUser) {
+            if (isComponentDisabled(map, Consts.SDK_IRONSOURCE, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
+                throw new IllegalConfigurationException("IronSource is disabled.");
+            }
+            return EAIronSource.createIronSourceRewardedInterstitialManager(callable, map, z);
+        }
+        if (TextUtils.equals(string, "max") || TextUtils.equals(string, Consts.SDK_APPLOVIN) || TextUtils.equals(string, Consts.SDK_MOPUB)) {
+            if (isComponentDisabled(map, "max", Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
+                throw new IllegalConfigurationException("MAX is disabled.");
+            }
+            if (isComponentDisabled(map, Consts.SDK_APPLOVIN, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
+                throw new IllegalConfigurationException("appLovin is disabled.");
+            }
+            GluEventBus eventBus = eventBus(map);
+            if (eventBus != GluEventBus.DISCONNECTED && !ConfigUtil.getBoolean(configDisabled(map), "rewardedInterstitialCrossPromoBlocked", false)) {
+                gluEventBus = eventBus;
+            }
+            return EAMax.createRVManager(callable, map, z, gluEventBus);
+        }
+        YLoggers.componentConfiguration(this.log, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, "l", Consts.SDK_GLU_ADS, i.a, "unsupportedType", Consts.KEY_TAPJOY_USER_ID_VERSION, string);
+        return null;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @Nullable
+    public IAdvertising createOfferWallOrDie(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @NonNull KillSwitch killSwitch, @NonNull DebugSettings debugSettings, boolean z, LoadingScreen loadingScreen, @Nullable CustomSettings customSettings) {
+        String string = ConfigUtil.getString(configComponents(map), Consts.ADVERTISEMENT_TYPE_OFFER_WALL);
+        if (TextUtils.isEmpty(string) || isComponentDisabled(map, Consts.SDK_TAPJOY, Consts.ADVERTISEMENT_TYPE_OFFER_WALL)) {
+            YLoggers.componentConfiguration(this.log, Consts.ADVERTISEMENT_TYPE_OFFER_WALL, "enabled", Boolean.FALSE);
+            return null;
+        }
+        if (TextUtils.equals(string, Consts.SDK_TAPJOY) || TextUtils.equals(string, Consts.SDK_MOPUB) || TextUtils.equals(string, "fyber")) {
+            YLoggers.componentConfiguration(this.log, Consts.ADVERTISEMENT_TYPE_OFFER_WALL, "l", Consts.SDK_GLU_ADS, Consts.KEY_TAPJOY_USER_ID_VERSION, string);
+            return createTapjoyOfferWallManager(callable, map, map2, loadingScreen, z, customSettings);
+        }
+        YLoggers.componentConfigurationError(this.log, Consts.ADVERTISEMENT_TYPE_OFFER_WALL, "l", Consts.SDK_GLU_ADS, "e", "unsupportedType", Consts.KEY_TAPJOY_USER_ID_VERSION, string);
+        throw new IllegalConfigurationException("Unsupported offerWall type: " + string + Consts.STRING_PERIOD);
+    }
+
+    @Nullable
+    private IAdvertising createBannerOrDie(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @NonNull KillSwitch killSwitch, @NonNull DebugSettings debugSettings, boolean z, @NonNull CustomSettings customSettings) {
+        String string = ConfigUtil.getString(configComponents(map), "banner");
+        if (TextUtils.isEmpty(string)) {
+            YLoggers.componentConfiguration(this.log, "banner", "enabled", Boolean.FALSE);
+            return null;
+        }
+        YLoggers.componentConfiguration(this.log, "banner", "l", Consts.SDK_GLU_ADS, i.a, "unsupportedType", Consts.KEY_TAPJOY_USER_ID_VERSION, string);
+        return null;
+    }
+
+    @Nullable
+    private IAdvertising createTapjoyOfferWallManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @Nullable LoadingScreen loadingScreen, boolean z, @Nullable CustomSettings customSettings) {
+        if (!AdvertisingUtil.isAPIEnabled()) {
+            return new DummyAdvertising();
+        }
+        Map<String, Object> configMapVariant = ConfigUtil.getConfigMapVariant(configSdk(map), "tapjoy.offerWallPlacementMapping", z, null);
+        if (Common.isEmpty(configMapVariant)) {
+            throw new IllegalConfigurationException("Tapjoy does not have offer wall placement mapping.");
+        }
+        Map<String, String> mapSSFromConfig = Common.mapSSFromConfig(configMapVariant);
+        TapjoyOfferWallManager tapjoyOfferWallManager = new TapjoyOfferWallManager(callable, mapSSFromConfig, mapSSFromConfig.remove(ProxyConfig.MATCH_ALL_SCHEMES), loadingScreen);
+        customSettings.tapjoyConnectState.setListener(tapjoyOfferWallManager);
+        return tapjoyOfferWallManager;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @NonNull
+    public Future<?> createTapjoy(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @NonNull final CustomSettings customSettings, final boolean z, PrivacyStatus privacyStatus, @NonNull AdvertisingImpl advertisingImpl) {
+        this.log.d("SDK.VERSION", Consts.SDK_TAPJOY, Tapjoy.getVersion());
+        Map<String, Object> configDisabled = configDisabled(map);
+        final String string = ConfigUtil.getString(configSdk(map), "tapjoy.sdkKey");
+        final Activity activity = (Activity) Common.call(callable);
+        customSettings.tapjoyConnectState = new TapjoyConnectState();
+        if (ConfigUtil.getBoolean(configDisabled, Consts.SDK_TAPJOY)) {
+            YLoggers.sdkConfiguration(this.log, Consts.SDK_TAPJOY, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_TAPJOY, "disabled", null, advertisingImpl);
+            return disabledFuture();
+        }
+        if (!AdvertisingUtil.isAPIEnabled()) {
+            YLoggers.sdkConfiguration(this.log, Consts.SDK_TAPJOY, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE, "DISABLE", "API", Consts.KEY_TAPJOY_USER_ID_VERSION, Integer.valueOf(Build.VERSION.SDK_INT));
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_TAPJOY, "disabled", null, advertisingImpl);
+            return disabledFuture();
+        }
+        advertisingImpl.updatePrivacyStage(Consts.SDK_TAPJOY, "started");
+        AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_TAPJOY, Consts.SDK_PRIVACY_STAGE_ADDED, new IAction1<PrivacyStatus>() { // from class: csdk.gluads.GluAdsFactory.7
+            @Override // csdk.gluads.util.IAction1
+            public void apply(PrivacyStatus privacyStatus2) {
+                TJPrivacyPolicy privacyPolicy = Tapjoy.getPrivacyPolicy();
+                if (privacyStatus2.gdprApplies) {
+                    GluAdsFactory.this.log.d("GDPR.APPLIES", Consts.SDK_TAPJOY, "No getter provided by the SDK.");
+                    GluAdsFactory.this.log.d("ADS.CONSENT", Consts.SDK_TAPJOY, "No getter provided by the SDK.");
+                    privacyPolicy.setUserConsent(privacyStatus2.hasConsent ? TJStatus.TRUE : TJStatus.FALSE);
+                    privacyPolicy.setSubjectToGDPR(TJStatus.TRUE);
+                }
+                if (privacyStatus2.ccpaApplies) {
+                    privacyPolicy.setUSPrivacy(privacyStatus2.ccpaOptOut ? "1YY-" : "1YN-");
+                    if (z) {
+                        GluAdsFactory.this.log.d("CCPA", "l", Consts.SDK_TAPJOY, b4.j, "No getter provided by the SDK.");
+                    }
+                } else {
+                    privacyPolicy.setUSPrivacy("1---");
+                }
+                privacyPolicy.setBelowConsentAge(privacyStatus2.underAgeUser ? TJStatus.TRUE : TJStatus.FALSE);
+                Tapjoy.optOutAdvertisingID(activity, privacyStatus2.underAgeUser);
+            }
+        }, advertisingImpl);
+        final Futures.SettableFuture settableFuture = Futures.settable();
+        if (TextUtils.isEmpty(string)) {
+            settableFuture.set(Consts.SDK_TAPJOY);
+        } else {
+            final Hashtable hashtable = new Hashtable();
+            hashtable.put(TapjoyConnectFlag.ENABLE_LOGGING, Boolean.valueOf(z));
+            Common.runOnUIThread(new Runnable() { // from class: csdk.gluads.GluAdsFactory.8
+                @Override // java.lang.Runnable
+                public void run() {
+                    customSettings.tapjoyConnectState.set(true);
+                    Tapjoy.connect(activity, string, hashtable, new TJConnectListener() { // from class: csdk.gluads.GluAdsFactory.8.1
+                        @Override // com.tapjoy.TJConnectListener, com.tapjoy.TJConnectInterface
+                        public void onConnectSuccess() {
+                            YLoggers.sdkConfiguration(GluAdsFactory.this.log, Consts.SDK_TAPJOY, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.TRUE);
+                            settableFuture.set(Consts.SDK_TAPJOY);
+                            Tapjoy.setDebugEnabled(z);
+                            Tapjoy.setActivity(activity);
+                            Tapjoy.startSession();
+                            GluAdsFactory.this.log.d("TAPJOY.CONNECT", "l", Consts.SDK_TAPJOY, InneractiveMediationDefs.GENDER_MALE, Boolean.FALSE);
+                            customSettings.tapjoyConnectState.set(false);
+                            customSettings.tapjoyConnectState.setListener(null);
+                        }
+
+                        @Override // com.tapjoy.TJConnectListener, com.tapjoy.TJConnectInterface
+                        public void onConnectFailure(int i, String str) {
+                            Exception exc = new Exception("Tapjoy SDK is not initialized. code=" + i + ", m=" + str);
+                            YLoggers.sdkConfigurationError(GluAdsFactory.this.log, Consts.SDK_TAPJOY, "l", Consts.SDK_GLU_ADS, "e", exc);
+                            settableFuture.setException(exc);
+                            GluAdsFactory.this.log.d("TAPJOY.CONNECT", "l", Consts.SDK_TAPJOY, InneractiveMediationDefs.GENDER_MALE, Boolean.FALSE, "tj-c", Integer.valueOf(i), "tj-m", str);
+                            customSettings.tapjoyConnectState.set(false);
+                            customSettings.tapjoyConnectState.setListener(null);
+                        }
+                    });
+                }
+            });
+        }
+        return settableFuture;
+    }
+}

decompiled/sources/csdk/gluads/GluAdsNativeBridge.java

@@ -0,0 +1,146 @@
+package csdk.gluads;
+
+import android.app.Activity;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import csdk.gluads.util.Common;
+import java.lang.ref.WeakReference;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes4.dex */
+public class GluAdsNativeBridge implements IAdvertisingListener {
+    private static long mNativeData;
+    private IAdvertising mAdvertising;
+    private WeakReference<Activity> mLastActivity;
+
+    private static native void destroy(long j);
+
+    public static native void destroyAnzuSDK();
+
+    public static native void disableCallTracking();
+
+    public static native void discardNativeAd(long j, String str);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static native Activity getCurrentActivity(long j);
+
+    public static long getNativeData() {
+        return mNativeData;
+    }
+
+    public static native void initAnzuSDK(String str, String str2, boolean z, boolean z2, boolean z3, boolean z4, boolean z5, boolean z6);
+
+    public static native void initNativeAdImpl(long j, boolean z, String str);
+
+    public static native void loadNativeAd(long j, String str, String str2);
+
+    private static native void onCustomActionReceived(long j, String str);
+
+    private static native void onPlacementEvent(long j, String str, String str2, String str3, String str4, Map<String, Object> map, long j2);
+
+    private static native void onRewardReceived(long j, String str, String str2, String str3, int i, String str4);
+
+    public static native void pauseAnzu(long j);
+
+    public static native void resumeAnzu(long j);
+
+    public static native void setListener(long j, IAdvertisingListener iAdvertisingListener);
+
+    public static native void showNativeAd(long j, String str, String str2);
+
+    public GluAdsNativeBridge(long j, String str) {
+        if (!TextUtils.equals(BuildConfig.VERSION_NAME, str)) {
+            throw new RuntimeException("Bridge library is mismatched '7.6.4-ec99fc8' vs '" + str + "'");
+        }
+        this.mLastActivity = new WeakReference<>(getCurrentActivity(j));
+        mNativeData = j;
+    }
+
+    public void destroy() {
+        synchronized (this) {
+            try {
+                long j = mNativeData;
+                mNativeData = 0L;
+                if (j != 0) {
+                    destroy(j);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public IAdvertising createGluAds(String str, Map<String, Object> map) {
+        IAdvertising createAdvertising = new GluAdsFactory().createAdvertising(new Callable<Activity>() { // from class: csdk.gluads.GluAdsNativeBridge.1
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // java.util.concurrent.Callable
+            public Activity call() throws Exception {
+                synchronized (GluAdsNativeBridge.this) {
+                    try {
+                        if (GluAdsNativeBridge.mNativeData == 0) {
+                            return (Activity) GluAdsNativeBridge.this.mLastActivity.get();
+                        }
+                        Activity currentActivity = GluAdsNativeBridge.getCurrentActivity(GluAdsNativeBridge.mNativeData);
+                        GluAdsNativeBridge.this.mLastActivity = new WeakReference(currentActivity);
+                        return currentActivity;
+                    } catch (Throwable th) {
+                        throw th;
+                    }
+                }
+            }
+        }, Common.emptyToNull(str), map);
+        this.mAdvertising = createAdvertising;
+        return createAdvertising;
+    }
+
+    public void setAdvertisingListener() {
+        this.mAdvertising.setAdvertisingListener(this);
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onCustomActionReceived(@NonNull CustomAction customAction) {
+        synchronized (this) {
+            try {
+                long j = mNativeData;
+                if (j != 0) {
+                    onCustomActionReceived(j, customAction.action);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onPlacementEvent(@NonNull PlacementEvent placementEvent) {
+        synchronized (this) {
+            try {
+                long j = mNativeData;
+                if (j != 0) {
+                    String str = placementEvent.advertisementType;
+                    String str2 = placementEvent.placement;
+                    String str3 = placementEvent.status;
+                    Throwable th = placementEvent.error;
+                    onPlacementEvent(j, str, str2, str3, th != null ? th.getMessage() : null, placementEvent.extra, placementEvent.textureInfo);
+                }
+            } catch (Throwable th2) {
+                throw th2;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onRewardReceived(@NonNull Reward reward) {
+        synchronized (this) {
+            try {
+                long j = mNativeData;
+                if (j != 0) {
+                    onRewardReceived(j, reward.identifier, reward.advertisementType, reward.item, reward.amount, reward.placement);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/csdk/gluads/IAdvertising.java

@@ -0,0 +1,48 @@
+package csdk.gluads;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface IAdvertising {
+    void destroy();
+
+    void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map);
+
+    Reward getReward(@NonNull String str, @NonNull String str2);
+
+    void internal_onNewSession();
+
+    void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map);
+
+    void internal_updateAdsFrequency(@NonNull Map<String, Object> map);
+
+    void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2);
+
+    void internal_updatePrivacyStatus(PrivacyStatus privacyStatus);
+
+    void internal_updateRewardList(@NonNull Map<String, Object> map);
+
+    boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map);
+
+    void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map);
+
+    @Deprecated
+    void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map);
+
+    @Deprecated
+    void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map);
+
+    void onPause();
+
+    void onResume();
+
+    void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener);
+
+    void setCustomProperties(@Nullable Map<String, Object> map);
+
+    void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map);
+
+    void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map);
+}

decompiled/sources/csdk/gluads/IAdvertisingListener.java

@@ -0,0 +1,13 @@
+package csdk.gluads;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes4.dex */
+public interface IAdvertisingListener {
+    @Deprecated
+    void onCustomActionReceived(@NonNull CustomAction customAction);
+
+    void onPlacementEvent(@NonNull PlacementEvent placementEvent);
+
+    void onRewardReceived(@NonNull Reward reward);
+}

decompiled/sources/csdk/gluads/KillSwitch.java

@@ -0,0 +1,11 @@
+package csdk.gluads;
+
+import java.util.concurrent.Future;
+
+/* loaded from: classes4.dex */
+public class KillSwitch {
+    public static final KillSwitch DEFAULT = new KillSwitch();
+    public Future<?> appLovinEnabled;
+    public Future<?> ironSourceEnabled;
+    public Future<?> tapjoyEnabled;
+}

decompiled/sources/csdk/gluads/LoadingScreen.java

@@ -0,0 +1,65 @@
+package csdk.gluads;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.view.ViewGroup;
+import android.widget.ProgressBar;
+import androidx.annotation.NonNull;
+import csdk.gluads.util.Common;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes4.dex */
+public class LoadingScreen {
+    private Callable<Activity> mActivityGetter;
+    private Context mCurrentContext;
+    private boolean mInitialized = false;
+    private CustomProgressBar mLoadingScreen;
+
+    public boolean isInitialized() {
+        return this.mInitialized;
+    }
+
+    public void initialize(@NonNull Callable<Activity> callable) {
+        this.mActivityGetter = callable;
+        Context context = (Context) Common.call(callable);
+        this.mCurrentContext = context;
+        CustomProgressBar customProgressBar = new CustomProgressBar(context);
+        this.mLoadingScreen = customProgressBar;
+        customProgressBar.setCancelable(true);
+        this.mLoadingScreen.setOnCancelListener(new DialogInterface.OnCancelListener() { // from class: csdk.gluads.LoadingScreen.1
+            @Override // android.content.DialogInterface.OnCancelListener
+            public void onCancel(DialogInterface dialogInterface) {
+            }
+        });
+        this.mLoadingScreen.addContentView(new ProgressBar(context), new ViewGroup.LayoutParams(-2, -2));
+        this.mInitialized = true;
+    }
+
+    public void show() {
+        if (!this.mInitialized || isShowing()) {
+            return;
+        }
+        if (((Context) Common.call(this.mActivityGetter)) != this.mCurrentContext) {
+            initialize(this.mActivityGetter);
+        }
+        this.mLoadingScreen.show();
+    }
+
+    public boolean isShowing() {
+        return this.mInitialized && this.mLoadingScreen.isShowing();
+    }
+
+    public void dismiss() {
+        if (isShowing()) {
+            this.mLoadingScreen.dismiss();
+        }
+    }
+
+    public class CustomProgressBar extends Dialog {
+        public CustomProgressBar(Context context) {
+            super(context, R.style.CustomProgressBar);
+        }
+    }
+}

decompiled/sources/csdk/gluads/PlacementEvent.java

@@ -0,0 +1,40 @@
+package csdk.gluads;
+
+import csdk.gluads.util.ISerializableJsonObject;
+import csdk.gluads.util.JsonUtil;
+import java.util.Map;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class PlacementEvent implements ISerializableJsonObject {
+    public final String advertisementType;
+    public final Throwable error;
+    public final Map<String, Object> extra;
+    public final String placement;
+    public final String status;
+    public final long textureInfo;
+
+    public PlacementEvent(String str, String str2, String str3, Throwable th, Map<String, Object> map, long j) {
+        this.advertisementType = str;
+        this.placement = str2;
+        this.status = str3;
+        this.error = th;
+        this.extra = map;
+        this.textureInfo = j;
+    }
+
+    public PlacementEvent(String str, String str2, String str3, Throwable th, Map<String, Object> map) {
+        this(str, str2, str3, th, map, 0L);
+    }
+
+    @Override // csdk.gluads.util.ISerializableJsonObject
+    public void write(JSONStringer jSONStringer) throws JSONException {
+        JsonUtil.optKeyValue(jSONStringer, "advertisementType", this.advertisementType);
+        JsonUtil.optKeyValue(jSONStringer, "placement", this.placement);
+        JsonUtil.optKeyValue(jSONStringer, "status", this.status);
+        JsonUtil.optKeyValue(jSONStringer, "error", this.error);
+        JsonUtil.optKeyValue(jSONStringer, "extra", this.extra);
+        JsonUtil.optKeyValue(jSONStringer, "textureInfo", Long.valueOf(this.textureInfo));
+    }
+}

decompiled/sources/csdk/gluads/PrivacyStatus.java

@@ -0,0 +1,26 @@
+package csdk.gluads;
+
+/* loaded from: classes4.dex */
+public class PrivacyStatus {
+    public static final String CCPA_APPLIES = "ccpaApplies";
+    public static final String CCPA_OPT_OUT = "ccpaOptOut";
+    public static final String GDPR_APPLIES = "gdprApplies";
+    public static final String HAS_CONSENT = "hasConsent";
+    public static final String TEEN_USER = "teen";
+    public static final String UNDER_AGE_USER = "underAgeUser";
+    public final boolean ccpaApplies;
+    public final boolean ccpaOptOut;
+    public final boolean gdprApplies;
+    public final boolean hasConsent;
+    public final boolean teenUser;
+    public final boolean underAgeUser;
+
+    public PrivacyStatus(boolean z, boolean z2, boolean z3, boolean z4, boolean z5, boolean z6) {
+        this.gdprApplies = z;
+        this.hasConsent = z2;
+        this.ccpaApplies = z3;
+        this.ccpaOptOut = z4;
+        this.underAgeUser = z5;
+        this.teenUser = z6;
+    }
+}

decompiled/sources/csdk/gluads/R.java

@@ -0,0 +1,15 @@
+package csdk.gluads;
+
+/* loaded from: classes4.dex */
+public final class R {
+
+    public static final class style {
+        public static int CustomProgressBar = 0x7f1300c8;
+
+        private style() {
+        }
+    }
+
+    private R() {
+    }
+}

decompiled/sources/csdk/gluads/Reward.java

@@ -0,0 +1,39 @@
+package csdk.gluads;
+
+import csdk.gluads.util.ISerializableJsonObject;
+import csdk.gluads.util.JsonUtil;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class Reward implements ISerializableJsonObject {
+    public final String advertisementType;
+    public final int amount;
+    public final String identifier;
+    public final String item;
+    public final String mediationNetwork;
+    public final String placement;
+
+    public Reward(String str, String str2, String str3, String str4, String str5, int i) {
+        this.identifier = str;
+        this.placement = str2;
+        this.mediationNetwork = str3;
+        this.advertisementType = str4;
+        this.item = str5;
+        this.amount = i;
+    }
+
+    @Override // csdk.gluads.util.ISerializableJsonObject
+    public void write(JSONStringer jSONStringer) throws JSONException {
+        JsonUtil.optKeyValue(jSONStringer, "identifier", this.identifier);
+        JsonUtil.optKeyValue(jSONStringer, "placement", this.placement);
+        JsonUtil.optKeyValue(jSONStringer, Consts.MEDIATION_NETWORK, this.mediationNetwork);
+        JsonUtil.optKeyValue(jSONStringer, "advertisementType", this.advertisementType);
+        JsonUtil.optKeyValue(jSONStringer, "item", this.item);
+        jSONStringer.key("amount").value(this.amount);
+    }
+
+    public String toJson() {
+        return JsonUtil.toJson(this);
+    }
+}

decompiled/sources/csdk/gluads/UnityGluAdsFactory.java

@@ -0,0 +1,63 @@
+package csdk.gluads;
+
+import android.app.Activity;
+import android.text.TextUtils;
+import com.unity3d.player.UnityPlayer;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.JsonUtil;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class UnityGluAdsFactory {
+    public IAdvertising createAdvertising(String str, String str2, String str3) {
+        Map<String, Object> parseJsonObject;
+        Callable<Activity> callable = new Callable<Activity>() { // from class: csdk.gluads.UnityGluAdsFactory.1
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // java.util.concurrent.Callable
+            public Activity call() throws Exception {
+                Activity activity = UnityPlayer.currentActivity;
+                if (activity != null) {
+                    return activity;
+                }
+                throw new Error("Current activity is null.");
+            }
+        };
+        if (TextUtils.isEmpty(str3)) {
+            parseJsonObject = null;
+        } else {
+            try {
+                parseJsonObject = JsonUtil.parseJsonObject(str3);
+            } catch (JSONException e) {
+                throw Common.propagate(e);
+            }
+        }
+        IAdvertising createAdvertising = new GluAdsFactory().createAdvertising(callable, Common.emptyToNull(str2), parseJsonObject);
+        createAdvertising.setAdvertisingListener(new UnityAdvertisingListener(str));
+        return createAdvertising;
+    }
+
+    public static class UnityAdvertisingListener implements IAdvertisingListener {
+        private final String gameObject;
+
+        private UnityAdvertisingListener(String str) {
+            this.gameObject = str;
+        }
+
+        @Override // csdk.gluads.IAdvertisingListener
+        public void onCustomActionReceived(CustomAction customAction) {
+            UnityPlayer.UnitySendMessage(this.gameObject, "AndroidAdvertisingOnCustomActionReceived", JsonUtil.toJson(customAction));
+        }
+
+        @Override // csdk.gluads.IAdvertisingListener
+        public void onPlacementEvent(PlacementEvent placementEvent) {
+            UnityPlayer.UnitySendMessage(this.gameObject, "AndroidAdvertisingOnPlacementEvent", JsonUtil.toJson(placementEvent));
+        }
+
+        @Override // csdk.gluads.IAdvertisingListener
+        public void onRewardReceived(Reward reward) {
+            UnityPlayer.UnitySendMessage(this.gameObject, "AndroidAdvertisingOnRewardReceived", JsonUtil.toJson(reward));
+        }
+    }
+}

decompiled/sources/csdk/gluads/UnityMarshallingUtil.java

@@ -0,0 +1,58 @@
+package csdk.gluads;
+
+import android.text.TextUtils;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.JsonUtil;
+import java.util.Map;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class UnityMarshallingUtil {
+    public static boolean isLoaded(IAdvertising iAdvertising, String str, String str2, String str3) {
+        return iAdvertising.isLoaded(Common.emptyToNull(str), Common.emptyToNull(str2), toMap(str3));
+    }
+
+    public static void load(IAdvertising iAdvertising, String str, String str2, String str3) {
+        iAdvertising.load(Common.emptyToNull(str), Common.emptyToNull(str2), toMap(str3));
+    }
+
+    public static void show(IAdvertising iAdvertising, String str, String str2, String str3) {
+        iAdvertising.show(Common.emptyToNull(str), Common.emptyToNull(str2), toMap(str3));
+    }
+
+    public static void onAdvertisementImpression(IAdvertising iAdvertising, String str, String str2, String str3) {
+        iAdvertising.onAdvertisementImpression(Common.emptyToNull(str), Common.emptyToNull(str2), toMap(str3));
+    }
+
+    public static void onAdvertisementClick(IAdvertising iAdvertising, String str, String str2, String str3) {
+        iAdvertising.onAdvertisementClick(Common.emptyToNull(str), Common.emptyToNull(str2), toMap(str3));
+    }
+
+    public static void setUserIdentifier(IAdvertising iAdvertising, String str, String str2) {
+        iAdvertising.setUserIdentifier(Common.emptyToNull(str), toMap(str2));
+    }
+
+    public static void discard(IAdvertising iAdvertising, String str, String str2, String str3) {
+        iAdvertising.discard(Common.emptyToNull(str), Common.emptyToNull(str2), toMap(str3));
+    }
+
+    public static void setCustomProperties(IAdvertising iAdvertising, String str) {
+        iAdvertising.setCustomProperties(toMap(str));
+    }
+
+    public static String getReward(IAdvertising iAdvertising, String str, String str2) {
+        Reward reward = iAdvertising.getReward(str, str2);
+        return reward != null ? reward.toJson() : "";
+    }
+
+    private static Map<String, Object> toMap(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            return JsonUtil.parseJsonObject(str);
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+}

decompiled/sources/csdk/gluads/eventbus/ConfigGetterEventHandler.java

@@ -0,0 +1,80 @@
+package csdk.gluads.eventbus;
+
+import android.text.TextUtils;
+import com.facebook.share.internal.ShareConstants;
+import com.mbridge.msdk.MBridgeConstans;
+import csdk.gluads.eventbus.GluEventBus;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.IAction2;
+import java.util.Collections;
+
+/* loaded from: classes4.dex */
+public class ConfigGetterEventHandler implements GluEventBus.IEventHandler {
+    private static final String CHANNEL_SDK = "#csdk.gluAds";
+    private static final String ID_HANDLER = "@csdk.gluAds.configGetter";
+    private final String mDefaultConfig;
+    private final GluEventBus mEventBus;
+    private final IAction2<String, String> mInitFn;
+    private Object mToken;
+    private boolean mut_initialized;
+
+    private ConfigGetterEventHandler(GluEventBus gluEventBus, IAction2<String, String> iAction2, String str) {
+        this.mEventBus = gluEventBus;
+        this.mInitFn = iAction2;
+        this.mDefaultConfig = str;
+    }
+
+    public static ConfigGetterEventHandler subscribe(GluEventBus gluEventBus, Object obj, IAction2<String, String> iAction2, String str) {
+        ConfigGetterEventHandler configGetterEventHandler = new ConfigGetterEventHandler(gluEventBus, iAction2, str);
+        configGetterEventHandler.mToken = gluEventBus.subscribe(obj, ID_HANDLER, Collections.singletonList(CHANNEL_SDK), configGetterEventHandler);
+        return configGetterEventHandler;
+    }
+
+    public void requestConfig(long j) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#csdk.gluAds.evt", "configRequested", null, Collections.singletonMap("jsonConfig", this.mDefaultConfig)));
+        if (j > 0) {
+            Common.runOnUIThreadDelayed(new Runnable() { // from class: csdk.gluads.eventbus.ConfigGetterEventHandler.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConfigGetterEventHandler configGetterEventHandler = ConfigGetterEventHandler.this;
+                    configGetterEventHandler.initOnce(configGetterEventHandler.mDefaultConfig, "app-timeout");
+                    ConfigGetterEventHandler.this.onDestroy();
+                }
+            }, j);
+        }
+    }
+
+    public void onDestroy() {
+        this.mEventBus.unsubscribe(this.mToken);
+    }
+
+    @Override // csdk.gluads.eventbus.GluEventBus.IEventHandler
+    public void handleEvent(GluEventBus gluEventBus, Object obj, String str, GluEventBus.Event event) throws Exception {
+        String str2;
+        if (TextUtils.equals(event.channel, CHANNEL_SDK) && TextUtils.equals(event.action, "reconfigure")) {
+            String string = ConfigUtil.getString(event.data, "jsonConfig");
+            if (TextUtils.isEmpty(string)) {
+                string = this.mDefaultConfig;
+                str2 = MBridgeConstans.DYNAMIC_VIEW_WX_APP;
+            } else {
+                str2 = ConfigUtil.getString(event.data, ShareConstants.FEED_SOURCE_PARAM);
+            }
+            initOnce(string, str2);
+            gluEventBus.unsubscribe(obj);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void initOnce(String str, String str2) {
+        boolean z;
+        synchronized (this) {
+            z = this.mut_initialized;
+            this.mut_initialized = true;
+        }
+        if (z) {
+            return;
+        }
+        this.mInitFn.apply(str, str2);
+    }
+}

decompiled/sources/csdk/gluads/eventbus/GluAdsEventHandler.java

@@ -0,0 +1,261 @@
+package csdk.gluads.eventbus;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.webkit.ProxyConfig;
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import csdk.gluads.Consts;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.LoadingScreen;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.Reward;
+import csdk.gluads.eventbus.GluEventBus;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class GluAdsEventHandler implements GluEventBus.IEventHandler {
+    private static final String CHANNEL_GLOBAL_SDK = "#sdk";
+    private static final String CHANNEL_LIFECYCLE = "#eb.lifecycle";
+    private static final String CHANNEL_SDK = "#csdk.gluAds";
+    private static final String CHANNEL_SDK_EVT = "#csdk.gluAds.evt";
+    private static final String ID_HANDLER = "@csdk.gluAds";
+    private final IAdvertising mAdvertising;
+    private final GluEventBus mEventBus;
+    private LoadingScreen mLoadingScreen;
+    private Object mToken;
+    private String mDefaultFrequencyConfig = "";
+    private boolean mAutoRulesTagFetchOnShow = false;
+    private boolean mEnabledImpressionMapping = false;
+    private ArrayList<String> loadingPlacementsIAM = new ArrayList<>();
+    private ArrayList<String> readyPlacementsIAM = new ArrayList<>();
+    private ArrayList<String> showOnceLoadedPlacementsIAM = new ArrayList<>();
+
+    private void offerWallIAMPreLoad(Map<String, Object> map) {
+    }
+
+    public void enableAutoRulesTagFetchOnShow() {
+        this.mAutoRulesTagFetchOnShow = true;
+    }
+
+    public void enableImpressionMapping() {
+        this.mEnabledImpressionMapping = true;
+    }
+
+    private GluAdsEventHandler(GluEventBus gluEventBus, IAdvertising iAdvertising) {
+        this.mEventBus = gluEventBus;
+        this.mAdvertising = iAdvertising;
+    }
+
+    public static GluAdsEventHandler subscribe(GluEventBus gluEventBus, Object obj, IAdvertising iAdvertising) {
+        GluAdsEventHandler gluAdsEventHandler = new GluAdsEventHandler(gluEventBus, iAdvertising);
+        gluAdsEventHandler.mToken = gluEventBus.subscribe(obj, ID_HANDLER, Arrays.asList(CHANNEL_SDK, CHANNEL_LIFECYCLE, CHANNEL_GLOBAL_SDK), gluAdsEventHandler);
+        return gluAdsEventHandler;
+    }
+
+    public void onInit(String str, LoadingScreen loadingScreen) {
+        Map createMap = Common.createMap();
+        createMap.put("name", "GluAds");
+        createMap.put("version", str);
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#sdk.evt", "initialized", null, createMap));
+        this.loadingPlacementsIAM = new ArrayList<>();
+        this.readyPlacementsIAM = new ArrayList<>();
+        this.showOnceLoadedPlacementsIAM = new ArrayList<>();
+        this.mLoadingScreen = loadingScreen;
+    }
+
+    public void onDestroy() {
+        Map createMap = Common.createMap();
+        createMap.put("name", "GluAds");
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#sdk.evt", "destroyed", null, createMap));
+        this.mEventBus.unsubscribe(this.mToken);
+    }
+
+    public void requestRewardConfig(String str) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "rewardConfigRequested", null, Collections.singletonMap("rewardConfig", str)));
+    }
+
+    public void requestRulesConfig(String str, String str2) {
+        if (str != null) {
+            this.mDefaultFrequencyConfig = str;
+        }
+        Map createMap = Common.createMap();
+        createMap.put("frequencyConfig", this.mDefaultFrequencyConfig);
+        if (str2 != null) {
+            createMap.put(SDKConstants.PARAM_SESSION_ID, str2);
+        }
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "rulesConfigRequested", null, createMap));
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    /* JADX WARN: Code restructure failed: missing block: B:16:0x0024, code lost:
+    
+        if (r12.equals("destroy") == false) goto L6;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:72:0x00c6, code lost:
+    
+        if (r13.equals("rewardedInterstitialShowWhenReady") == false) goto L27;
+     */
+    @Override // csdk.gluads.eventbus.GluEventBus.IEventHandler
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public void handleEvent(csdk.gluads.eventbus.GluEventBus r12, java.lang.Object r13, java.lang.String r14, csdk.gluads.eventbus.GluEventBus.Event r15) {
+        /*
+            Method dump skipped, instructions count: 478
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: csdk.gluads.eventbus.GluAdsEventHandler.handleEvent(csdk.gluads.eventbus.GluEventBus, java.lang.Object, java.lang.String, csdk.gluads.eventbus.GluEventBus$Event):void");
+    }
+
+    public void onPlacementEvent(@NonNull PlacementEvent placementEvent) {
+        LoadingScreen loadingScreen;
+        Map<String, Object> createMap = Common.createMap();
+        createMap.put("placement", placementEvent.placement);
+        createMap.put("network", ConfigUtil.getString(placementEvent.extra, Consts.MEDIATION_NETWORK));
+        createMap.put(Consts.KEY_NAME_ADTYPE, placementEvent.advertisementType);
+        Map createMap2 = Common.createMap();
+        Map<String, Object> map = placementEvent.extra;
+        if (map != null) {
+            createMap2.putAll(map);
+            createMap2.remove(Consts.MEDIATION_NETWORK);
+        }
+        GluEventBus.Event event = new GluEventBus.Event();
+        event.channel = CHANNEL_SDK_EVT;
+        if (placementEvent.status.equals(Consts.PLACEMENT_STATUS_LOAD_FINISHED)) {
+            if (this.loadingPlacementsIAM.contains(placementEvent.placement) && placementEvent.advertisementType.equals(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL) && (loadingScreen = this.mLoadingScreen) != null && loadingScreen.isShowing()) {
+                this.mLoadingScreen.dismiss();
+            }
+            Throwable th = placementEvent.error;
+            if (th != null) {
+                if (th.getCause() != null) {
+                    createMap2.put("errorCode", placementEvent.error.getCause().getMessage());
+                }
+                event.action = "advertisementFailedToLoad";
+                if (ConfigUtil.getBoolean(placementEvent.extra, Consts.KEY_NAME_FREQUENCY_REFRESH, false)) {
+                    placementEvent.extra.remove(Consts.KEY_NAME_FREQUENCY_REFRESH);
+                    requestRulesConfig(null, null);
+                }
+            } else {
+                event.action = "advertisementLoaded";
+                if (this.loadingPlacementsIAM.contains(placementEvent.placement)) {
+                    if (this.showOnceLoadedPlacementsIAM.contains(placementEvent.placement)) {
+                        this.mAdvertising.show(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, placementEvent.placement, null);
+                        this.showOnceLoadedPlacementsIAM.remove(placementEvent.placement);
+                    } else {
+                        this.readyPlacementsIAM.add(placementEvent.placement);
+                    }
+                }
+            }
+            if (this.loadingPlacementsIAM.contains(placementEvent.placement)) {
+                this.loadingPlacementsIAM.remove(placementEvent.placement);
+            }
+        } else if (placementEvent.status.equals(Consts.PLACEMENT_STATUS_SHOW_STARTED)) {
+            if (placementEvent.error == null) {
+                event.action = "advertisementShown";
+                String string = ConfigUtil.getString(placementEvent.extra, "adNetwork");
+                if (!TextUtils.isEmpty(string)) {
+                    createMap2.put(Consts.SERVED_BY_NETWORK, string);
+                }
+            }
+        } else if (placementEvent.status.equals(Consts.PLACEMENT_STATUS_SHOW_BLOCKED) && placementEvent.error == null) {
+            event.action = "crossPromoBlocked";
+        } else if (placementEvent.status.equals(Consts.PLACEMENT_STATUS_SHOW_FINISHED)) {
+            if (placementEvent.error == null) {
+                event.action = "advertisementDismissed";
+            }
+            if (this.mAutoRulesTagFetchOnShow) {
+                requestRulesConfig(null, null);
+            }
+        } else if (placementEvent.status.equals(Consts.PLACEMENT_STATUS_CLICKED)) {
+            if (placementEvent.error == null) {
+                event.action = "advertisementClicked";
+            }
+        } else if (placementEvent.status.equals(Consts.SINGULAR_AD_REVENUE_REPORT)) {
+            if (placementEvent.error == null) {
+                event.action = Consts.SINGULAR_AD_REVENUE_REPORT;
+            }
+        } else if (placementEvent.status.equals(Consts.PLACEMENT_STATUS_SHOW_ATTEMPT)) {
+            event.action = "advertisementShowAttempt";
+        }
+        if (TextUtils.isEmpty(event.action)) {
+            return;
+        }
+        createMap.put("extra", createMap2);
+        event.data = createMap;
+        this.mEventBus.publish(this.mToken, event);
+    }
+
+    public void onRewardReceived(@NonNull Reward reward) {
+        Map createMap = Common.createMap();
+        createMap.put("placement", reward.placement);
+        createMap.put("network", reward.mediationNetwork);
+        createMap.put(Consts.KEY_NAME_ADTYPE, reward.advertisementType);
+        createMap.put("item", reward.item);
+        createMap.put("amount", Integer.valueOf(reward.amount));
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "rewardReceived", null, createMap));
+    }
+
+    private void setGemsData(Map<String, Object> map) {
+        String string = ConfigUtil.getString(map, "id");
+        if (string != null) {
+            this.mAdvertising.internal_setGemsData(string, null);
+        }
+    }
+
+    private void offerWallIAMShowWhenReady(Map<String, Object> map) {
+        this.mAdvertising.show(Consts.ADVERTISEMENT_TYPE_OFFER_WALL, ConfigUtil.getString(map, "placement", ProxyConfig.MATCH_ALL_SCHEMES), null);
+    }
+
+    private void rewardedInterstitialIAMPreLoad(Map<String, Object> map) {
+        String string = ConfigUtil.getString(map, "placement", ProxyConfig.MATCH_ALL_SCHEMES);
+        if (this.loadingPlacementsIAM.contains(string)) {
+            return;
+        }
+        this.loadingPlacementsIAM.add(string);
+        this.mAdvertising.load(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, string, null);
+    }
+
+    private void rewardedInterstitialIAMShowWhenReady(Map<String, Object> map) {
+        String string = ConfigUtil.getString(map, "placement", ProxyConfig.MATCH_ALL_SCHEMES);
+        if (this.readyPlacementsIAM.contains(string)) {
+            this.mAdvertising.show(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, string, null);
+            this.readyPlacementsIAM.remove(string);
+            return;
+        }
+        if (!this.loadingPlacementsIAM.contains(string)) {
+            this.loadingPlacementsIAM.add(string);
+            this.mAdvertising.load(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, string, null);
+        }
+        this.showOnceLoadedPlacementsIAM.add(string);
+        if (this.mLoadingScreen != null) {
+            Common.runOnUIThread(new Runnable() { // from class: csdk.gluads.eventbus.GluAdsEventHandler.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    GluAdsEventHandler.this.mLoadingScreen.show();
+                }
+            });
+        }
+    }
+
+    private void handleCrossPromotionTag(Map<String, Object> map) {
+        Map createMap = Common.createMap();
+        Map map2 = Collections.EMPTY_MAP;
+        createMap.put(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, map2);
+        createMap.put("interstitial", map2);
+        if (ConfigUtil.getBoolean(map, "crossPromo", false)) {
+            for (Map.Entry<String, Object> entry : ConfigUtil.getMap(map, "crossPromoPlacementMapping", map2).entrySet()) {
+                createMap.put(entry.getKey(), (Map) entry.getValue());
+            }
+        }
+        Map<String, Object> map3 = this.mEnabledImpressionMapping ? ConfigUtil.getMap(map, "impressionMapping") : null;
+        for (Map.Entry entry2 : createMap.entrySet()) {
+            this.mAdvertising.internal_updateCrossPromotion((String) entry2.getKey(), (Map) entry2.getValue(), map3);
+        }
+    }
+}

decompiled/sources/csdk/gluads/eventbus/GluAdsManagerEventHandler.java

@@ -0,0 +1,78 @@
+package csdk.gluads.eventbus;
+
+import androidx.annotation.Nullable;
+import com.ironsource.jo;
+import csdk.gluads.eventbus.GluEventBus;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes4.dex */
+public class GluAdsManagerEventHandler implements GluEventBus.IEventHandler {
+    private static final String CHANNEL_GLUCENTRALSERVICES = "#csdk.gluCentralServices";
+    private static final String PREFIX_CHANNEL = "#csdk.gluAdsManager";
+    private static final String PREFIX_HANDLER = "@csdk.gluAdsManager";
+    private String mChannel;
+    private GluEventBus mEventBus;
+    private String mHandler;
+    private final YLogger mLog = YLoggerFactory.getLogger(getClass());
+    private Object mToken = GluEventBus.GLOBAL_TOKEN;
+    private ConcurrentHashMap mCrossPromotionsBlocked = new ConcurrentHashMap();
+
+    public void directLoad(String str, @Nullable Map<String, Object> map) {
+    }
+
+    public GluAdsManagerEventHandler(String str) {
+        this.mChannel = PREFIX_CHANNEL + str;
+        this.mHandler = PREFIX_HANDLER + str;
+    }
+
+    public void subscribe(GluEventBus gluEventBus) {
+        this.mEventBus = gluEventBus;
+        this.mToken = gluEventBus.subscribe(GluEventBus.GLOBAL_TOKEN, this.mHandler, Arrays.asList(this.mChannel), this);
+    }
+
+    public void onDestroy() {
+        this.mEventBus.unsubscribe(this.mToken);
+    }
+
+    public void loadAdOnCrossPromoTargetAppCheck(String str, String str2, @Nullable Map<String, Object> map) {
+        Map createMap = Common.createMap();
+        createMap.put(jo.d, str);
+        createMap.put("campaignName", str2);
+        if (map != null) {
+            createMap.put("extra", map);
+        }
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_GLUCENTRALSERVICES, "requestCrossPromoTargetAppCheck", this.mChannel, createMap));
+    }
+
+    public boolean isCrossPromoBlocked(String str) {
+        return this.mCrossPromotionsBlocked.keySet().contains(str);
+    }
+
+    @Override // csdk.gluads.eventbus.GluEventBus.IEventHandler
+    public void handleEvent(GluEventBus gluEventBus, Object obj, String str, GluEventBus.Event event) throws Exception {
+        if (this.mChannel.equals(event.channel)) {
+            String str2 = event.action;
+            str2.hashCode();
+            if (str2.equals("responseCrossPromoTargetAppCheck")) {
+                String string = ConfigUtil.getString(event.data, jo.d, null);
+                Map<String, Object> map = ConfigUtil.getMap(event.data, "extra", null);
+                Boolean valueOf = Boolean.valueOf(ConfigUtil.getString(event.data, "status", "").equalsIgnoreCase("blocked"));
+                this.mLog.d("GluAds: responseCrossPromoTargetAppCheck", event.data.toString());
+                if (string != null) {
+                    if (valueOf.booleanValue()) {
+                        this.mCrossPromotionsBlocked.put(string, Boolean.TRUE);
+                    } else {
+                        this.mCrossPromotionsBlocked.remove(string);
+                    }
+                    directLoad(string, map);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,246 @@
+package csdk.gluads.eventbus;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import csdk.glucentralservices.eventbus.IServerEventBus;
+import csdk.glucentralservices.eventbus.IServerEventHandler;
+import csdk.glucentralservices.eventbus.ServerEventBus;
+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.gluads.eventbus.GluEventBus
+        public Object globalToken() {
+            return this;
+        }
+
+        @Override // csdk.gluads.eventbus.GluEventBus
+        public boolean isConnected() {
+            return false;
+        }
+
+        @Override // csdk.gluads.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+        }
+
+        @Override // csdk.gluads.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+        }
+
+        private DisconnectedEventBus() {
+        }
+
+        @Override // csdk.gluads.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.gluads.eventbus.GluEventBus
+        public boolean isConnected() {
+            return true;
+        }
+
+        public RealEventBus(IServerEventBus iServerEventBus) {
+            this.mEventBus = iServerEventBus;
+        }
+
+        @Override // csdk.gluads.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.gluads.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.gluads.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+            this.mEventBus.unsubscribe(obj);
+        }
+
+        @Override // csdk.gluads.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+            this.mEventBus.publish(obj, event);
+        }
+
+        @Override // csdk.gluads.eventbus.GluEventBus
+        public Object globalToken() {
+            return this.mEventBus.globalToken();
+        }
+    }
+}

decompiled/sources/csdk/gluads/impl/AdsSubscriber.java

@@ -0,0 +1,83 @@
+package csdk.gluads.impl;
+
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.text.TextUtils;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import csdk.gluads.Consts;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.util.broadcastmanager.IBroadcastManger;
+import csdk.gluads.util.broadcastmanager.ISubscriber;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import java.util.Collections;
+
+/* loaded from: classes4.dex */
+public class AdsSubscriber implements ISubscriber {
+    private final IAdvertisingListener mAdsListener;
+    private final int mNumPrivacyStages;
+    private String mServedByAdNetwork;
+    private final YLogger mLog = YLoggerFactory.getLogger(getClass());
+    private int privacyCounterDisabledUnsupported = 0;
+    private boolean privacyReady = false;
+    private int privacyCounter = 0;
+
+    public String GetServedByAdNetworkAndClear() {
+        String str = this.mServedByAdNetwork;
+        this.mServedByAdNetwork = "";
+        return str;
+    }
+
+    public boolean isPrivacyReady() {
+        return this.privacyReady;
+    }
+
+    private AdsSubscriber(IAdvertisingListener iAdvertisingListener, int i) {
+        this.mAdsListener = iAdvertisingListener;
+        this.mNumPrivacyStages = i;
+    }
+
+    public static AdsSubscriber subscribe(IBroadcastManger iBroadcastManger, IAdvertisingListener iAdvertisingListener, int i) {
+        IntentFilter intentFilter = new IntentFilter();
+        int i2 = 0;
+        while (true) {
+            String[] strArr = Consts.SDK_ARRAY_AD_NETWORKS;
+            if (i2 < strArr.length) {
+                intentFilter.addAction(strArr[i2]);
+                intentFilter.addAction("privacy.stage.added." + strArr[i2]);
+                intentFilter.addAction("privacy.stage.disabled." + strArr[i2]);
+                intentFilter.addAction("privacy.stage.unsupported." + strArr[i2]);
+                i2++;
+            } else {
+                AdsSubscriber adsSubscriber = new AdsSubscriber(iAdvertisingListener, i);
+                iBroadcastManger.subscribe(adsSubscriber, Collections.singleton(intentFilter));
+                return adsSubscriber;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.util.broadcastmanager.ISubscriber
+    public void onReceive(IBroadcastManger iBroadcastManger, Intent intent) {
+        String action = intent.getAction();
+        if (!TextUtils.isEmpty(action)) {
+            if (!action.contains(Consts.SDK_PRIVACY_STAGE_PREFIX)) {
+                this.mServedByAdNetwork = action;
+                return;
+            }
+            if (action.contains(Consts.SDK_PRIVACY_STAGE_ADDED)) {
+                this.privacyCounter++;
+            } else if (action.contains("disabled") || action.contains(Consts.SDK_PRIVACY_STAGE_UNSUPPORTED)) {
+                this.privacyCounterDisabledUnsupported++;
+            }
+            this.mLog.i("ADVERTISING.BROADCAST.PRIVACY.STATUS: " + action, new Object[0]);
+            if (this.privacyCounter == this.mNumPrivacyStages - this.privacyCounterDisabledUnsupported) {
+                this.mLog.i("ADVERTISING.BROADCAST.PRIVACY.READY", new Object[0]);
+                ((AdvertisingImpl) this.mAdsListener).handleOnInit();
+                this.privacyReady = true;
+                return;
+            }
+            return;
+        }
+        this.mLog.i("ADVERTISING.BROADCAST.ERROR", InneractiveMediationDefs.GENDER_MALE, "unsupported-action", Consts.KEY_TAPJOY_USER_ID_VERSION, action);
+    }
+}

decompiled/sources/csdk/gluads/impl/AdvertisingImpl.java

@@ -0,0 +1,415 @@
+package csdk.gluads.impl;
+
+import android.app.Activity;
+import android.content.Context;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.Consts;
+import csdk.gluads.CustomAction;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import csdk.gluads.eventbus.GluAdsEventHandler;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.GluActivityLifecycleCallbacks;
+import csdk.gluads.util.IAction1;
+import csdk.gluads.util.IAction2;
+import csdk.gluads.util.broadcastmanager.IBroadcastManger;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class AdvertisingImpl implements IAdvertising, IAdvertisingListener {
+    private Map<String, IAdvertising> handlers;
+    private boolean hasInitRun;
+    private final IBroadcastManger mBroadcastManager;
+    private Context mContext;
+    private GluAdsEventHandler mEventHandler;
+    private GluActivityLifecycleCallbacks mGluActivityLifecycleCallbacks;
+    private Runnable mOnDestroy;
+    private Runnable mOnInit;
+    private AdsSubscriber mSubscriber;
+    private Integer userAge;
+    private final AtomicReference<IAdvertisingListener> listener = new AtomicReference<>(NullAdvertisingListener.INSTANCE);
+    private Map<String, IAction1<PrivacyStatus>> mInitHandlers = Collections.synchronizedMap(Common.createMap());
+    private final Map<String, IAction1<PrivacyStatus>> mPrivacyStatusUpdateHandlers = Collections.synchronizedMap(Common.createMap());
+    private final Map<String, String> mPrivacyStages = Collections.synchronizedMap(Common.createMap());
+
+    @NonNull
+    public Map<String, IAdvertising> getComponentHandlers() {
+        return this.handlers;
+    }
+
+    public void updateUserAge(Integer num) {
+        this.userAge = num;
+    }
+
+    public AdvertisingImpl(IBroadcastManger iBroadcastManger, Context context) {
+        this.mContext = context;
+        int i = 0;
+        while (true) {
+            String[] strArr = Consts.SDK_ARRAY_AD_NETWORKS;
+            if (i < strArr.length) {
+                this.mPrivacyStages.put(strArr[i], Consts.SDK_PRIVACY_STAGE_UNINITIALIZED);
+                i++;
+            } else {
+                this.mBroadcastManager = iBroadcastManger;
+                this.mSubscriber = AdsSubscriber.subscribe(iBroadcastManger, this, this.mPrivacyStages.size());
+                this.hasInitRun = false;
+                return;
+            }
+        }
+    }
+
+    public void initialize(Runnable runnable, Runnable runnable2, GluAdsEventHandler gluAdsEventHandler) {
+        this.mOnDestroy = runnable2;
+        this.mEventHandler = gluAdsEventHandler;
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().setAdvertisingListener(this);
+        }
+        this.mOnInit = runnable;
+        AdsSubscriber adsSubscriber = this.mSubscriber;
+        if (adsSubscriber != null && adsSubscriber.isPrivacyReady() && !this.hasInitRun) {
+            this.mOnInit.run();
+            this.hasInitRun = true;
+        }
+        this.mGluActivityLifecycleCallbacks = new GluActivityLifecycleCallbacks(this.mContext, new IAction2<String, Activity>() { // from class: csdk.gluads.impl.AdvertisingImpl.1
+            @Override // csdk.gluads.util.IAction2
+            public void apply(String str, Activity activity) {
+                if ("onApplicationResumed".equals(str)) {
+                    AdvertisingImpl.this.onResume();
+                } else if ("onApplicationPaused".equals(str)) {
+                    AdvertisingImpl.this.onPause();
+                }
+            }
+        });
+    }
+
+    public void rewireListeners() {
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().setAdvertisingListener(this);
+        }
+    }
+
+    public void handleOnInit() {
+        Runnable runnable = this.mOnInit;
+        if (runnable == null || this.hasInitRun) {
+            return;
+        }
+        runnable.run();
+        this.hasInitRun = true;
+    }
+
+    public void setComponentHandlers(@NonNull Map<String, IAdvertising> map) {
+        Common.require(map != null, "handlers can't be null.");
+        Map<String, IAdvertising> map2 = this.handlers;
+        if (map2 == null) {
+            this.handlers = map;
+            return;
+        }
+        Map<String, IAdvertising> shallowClone = Common.shallowClone(map2);
+        shallowClone.putAll(map);
+        this.handlers = shallowClone;
+    }
+
+    public void updatePrivacyStage(String str, String str2) {
+        this.mPrivacyStages.put(str, str2);
+    }
+
+    public void setAdvertisingPrivacyStage(String str, String str2, IAction1<PrivacyStatus> iAction1) {
+        this.mPrivacyStatusUpdateHandlers.put(str, iAction1);
+        this.mPrivacyStages.put(str, str2);
+    }
+
+    public void setInitHandler(String str, IAction1<PrivacyStatus> iAction1) {
+        this.mInitHandlers.put(str, iAction1);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
+        AtomicReference<IAdvertisingListener> atomicReference = this.listener;
+        if (iAdvertisingListener == null) {
+            iAdvertisingListener = NullAdvertisingListener.INSTANCE;
+        }
+        atomicReference.set(iAdvertisingListener);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        Common.require(str != null, "advertisementType can't be null.");
+        Common.require(str2 != null, "placement can't be null.");
+        IAdvertising iAdvertising = this.handlers.get(str);
+        return iAdvertising != null && iAdvertising.isLoaded(str, str2, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        Common.require(str != null, "advertisementType can't be null.");
+        Common.require(str2 != null, "placement can't be null.");
+        IAdvertising iAdvertising = this.handlers.get(str);
+        if (iAdvertising != null) {
+            iAdvertising.load(str, str2, putIfUserAgeIsPresent(map));
+            return;
+        }
+        this.listener.get().onPlacementEvent(new PlacementEvent(str, str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new UnsupportedOperationException("Unknown advertisementType: " + str + Consts.STRING_PERIOD), map));
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        Common.require(str != null, "advertisementType can't be null.");
+        Common.require(str2 != null, "placement can't be null.");
+        IAdvertising iAdvertising = this.handlers.get(str);
+        if (iAdvertising != null) {
+            iAdvertising.show(str, str2, putIfUserAgeIsPresent(map));
+            return;
+        }
+        this.listener.get().onPlacementEvent(new PlacementEvent(str, str2, Consts.PLACEMENT_STATUS_SHOW_FINISHED, new UnsupportedOperationException("Unknown advertisementType: " + str + Consts.STRING_PERIOD), map));
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        Common.require(str != null, "advertisementType can't be null.");
+        Common.require(str2 != null, "identifier can't be null.");
+        IAdvertising iAdvertising = this.handlers.get(str);
+        if (iAdvertising != null) {
+            iAdvertising.onAdvertisementImpression(str, str2, map);
+            return;
+        }
+        throw new UnsupportedOperationException("Unknown advertisementType: " + str + Consts.STRING_PERIOD);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        Common.require(str != null, "advertisementType can't be null.");
+        Common.require(str2 != null, "identifier can't be null.");
+        IAdvertising iAdvertising = this.handlers.get(str);
+        if (iAdvertising != null) {
+            iAdvertising.onAdvertisementClick(str, str2, map);
+            return;
+        }
+        throw new UnsupportedOperationException("Unknown advertisementType: " + str + Consts.STRING_PERIOD);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+        this.hasInitRun = false;
+        this.mBroadcastManager.unsubscribe();
+        this.listener.set(NullAdvertisingListener.INSTANCE);
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().destroy();
+        }
+        this.handlers.clear();
+        Runnable runnable = this.mOnDestroy;
+        if (runnable != null) {
+            runnable.run();
+        }
+        this.mGluActivityLifecycleCallbacks.destroy();
+        this.mGluActivityLifecycleCallbacks = null;
+        this.mContext = null;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().onPause();
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().onResume();
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().setUserIdentifier(str, map);
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().internal_setGemsData(str, map);
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        Common.require(str != null, "advertisementType can't be null.");
+        IAdvertising iAdvertising = this.handlers.get(str);
+        if (iAdvertising != null) {
+            iAdvertising.discard(str, str2, map);
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+        if (isPrivacyPolicyUpdate(map)) {
+            updatePrivacyStatus(map);
+        }
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().setCustomProperties(map);
+        }
+    }
+
+    private boolean isPrivacyPolicyUpdate(@Nullable Map<String, Object> map) {
+        return containsKey(map, PrivacyStatus.GDPR_APPLIES) && containsKey(map, PrivacyStatus.CCPA_APPLIES) && containsKey(map, PrivacyStatus.UNDER_AGE_USER) && containsKey(map, PrivacyStatus.TEEN_USER);
+    }
+
+    private void updatePrivacyStatus(Map<String, Object> map) {
+        internal_updatePrivacyStatus(new PrivacyStatus(Boolean.valueOf(ConfigUtil.getBoolean(map, PrivacyStatus.GDPR_APPLIES)).booleanValue(), Boolean.valueOf(ConfigUtil.getBoolean(map, PrivacyStatus.HAS_CONSENT)).booleanValue(), Boolean.valueOf(ConfigUtil.getBoolean(map, PrivacyStatus.CCPA_APPLIES)).booleanValue(), Boolean.valueOf(ConfigUtil.getBoolean(map, PrivacyStatus.CCPA_OPT_OUT)).booleanValue(), Boolean.valueOf(ConfigUtil.getBoolean(map, PrivacyStatus.UNDER_AGE_USER)).booleanValue(), Boolean.valueOf(ConfigUtil.getBoolean(map, PrivacyStatus.TEEN_USER)).booleanValue()));
+    }
+
+    private boolean containsKey(@Nullable Map<String, Object> map, String str) {
+        return map != null && map.containsKey(str);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        Common.require(str != null, "advertisementType can't be null.");
+        Common.require(str2 != null, "placement can't be null.");
+        IAdvertising iAdvertising = this.handlers.get(str);
+        if (iAdvertising != null) {
+            return iAdvertising.getReward(str, str2);
+        }
+        return null;
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onCustomActionReceived(@NonNull CustomAction customAction) {
+        this.listener.get().onCustomActionReceived(customAction);
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onPlacementEvent(@NonNull PlacementEvent placementEvent) {
+        Map<String, Object> map;
+        if (TextUtils.equals(placementEvent.status, Consts.PLACEMENT_STATUS_SHOW_STARTED)) {
+            String GetServedByAdNetworkAndClear = this.mSubscriber.GetServedByAdNetworkAndClear();
+            if (!TextUtils.isEmpty(GetServedByAdNetworkAndClear) && (map = placementEvent.extra) != null) {
+                map.put(Consts.SERVED_BY_NETWORK, GetServedByAdNetworkAndClear);
+            }
+        }
+        this.mEventHandler.onPlacementEvent(placementEvent);
+        if (TextUtils.equals(placementEvent.status, Consts.PLACEMENT_STATUS_SHOW_ATTEMPT) || TextUtils.equals(placementEvent.status, Consts.SINGULAR_AD_REVENUE_REPORT)) {
+            return;
+        }
+        if ((TextUtils.equals(placementEvent.status, Consts.PLACEMENT_STATUS_SHOW_STARTED) && TextUtils.equals(placementEvent.advertisementType, "banner") && Common.get(placementEvent.extra, Consts.KEY_NAME_PUB_REVENUE) != null) || placementEvent.placement == null) {
+            return;
+        }
+        if (placementEvent.advertisementType == "nativeAd") {
+            this.listener.get().onPlacementEvent(placementEvent);
+        } else {
+            this.listener.get().onPlacementEvent(dropPlacementEventExtraIfNotRequired(placementEvent));
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onRewardReceived(@NonNull Reward reward) {
+        this.mEventHandler.onRewardReceived(reward);
+        this.listener.get().onRewardReceived(reward);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+        int size = this.mPrivacyStages.size() * 3;
+        int i = 0;
+        String str = "";
+        for (Map.Entry<String, String> entry : this.mPrivacyStages.entrySet()) {
+            String value = entry.getValue();
+            if (value.equals(Consts.SDK_PRIVACY_STAGE_UNINITIALIZED)) {
+                str = str + entry.getKey() + " " + Consts.SDK_PRIVACY_STAGE_UNINITIALIZED + " ";
+            } else if (value.equals("disabled") || value.equals(Consts.SDK_PRIVACY_STAGE_UNSUPPORTED)) {
+                size -= 3;
+            } else if (value.equals("started")) {
+                i += 2;
+                str = str + entry.getKey() + " started ";
+            } else if (value.equals(Consts.SDK_PRIVACY_STAGE_ADDED)) {
+                i += 3;
+            }
+        }
+        if (i == size) {
+            Map<String, IAction1<PrivacyStatus>> map = this.mInitHandlers;
+            if (map != null) {
+                this.mInitHandlers = null;
+                Iterator<IAction1<PrivacyStatus>> it = map.values().iterator();
+                while (it.hasNext()) {
+                    it.next().apply(privacyStatus);
+                }
+            }
+            for (IAction1<PrivacyStatus> iAction1 : this.mPrivacyStatusUpdateHandlers.values()) {
+                if (iAction1 != null) {
+                    iAction1.apply(privacyStatus);
+                }
+            }
+            return;
+        }
+        throw new UnsupportedOperationException("Not all privacy status have been collected: " + str);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().internal_updateRewardList(map);
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().internal_updateAdsFrequency(map);
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+        IAdvertising iAdvertising;
+        if ((TextUtils.equals(str, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL) || TextUtils.equals(str, "interstitial")) && (iAdvertising = this.handlers.get(str)) != null) {
+            iAdvertising.internal_updateCrossPromotion(str, map, map2);
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+        Iterator<IAdvertising> it = this.handlers.values().iterator();
+        while (it.hasNext()) {
+            it.next().internal_onNewSession();
+        }
+    }
+
+    private PlacementEvent dropPlacementEventExtraIfNotRequired(PlacementEvent placementEvent) {
+        return placementEvent.extra == null ? placementEvent : new PlacementEvent(placementEvent.advertisementType, placementEvent.placement, placementEvent.status, placementEvent.error, null, placementEvent.textureInfo);
+    }
+
+    private Map<String, Object> putIfUserAgeIsPresent(@Nullable Map<String, Object> map) {
+        Integer num = this.userAge;
+        if (num == null || num.intValue() < 0) {
+            return map;
+        }
+        Map<String, Object> createMap = Common.createMap();
+        if (map != null) {
+            createMap.putAll(map);
+        }
+        createMap.put(Consts.EXTRA_KEYWORDS_AGE, String.format(Locale.ENGLISH, "m_age:%d", this.userAge));
+        return createMap;
+    }
+}

decompiled/sources/csdk/gluads/impl/AdvertisingProxy.java

@@ -0,0 +1,140 @@
+package csdk.gluads.impl;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.CustomAction;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public abstract class AdvertisingProxy implements IAdvertising, IAdvertisingListener {
+    private final AtomicReference<IAdvertisingListener> mListener = new AtomicReference<>(NullAdvertisingListener.INSTANCE);
+    private IAdvertising mNext;
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+    }
+
+    public IAdvertising next() {
+        return this.mNext;
+    }
+
+    public void init(@NonNull IAdvertising iAdvertising) {
+        this.mNext = iAdvertising;
+        iAdvertising.setAdvertisingListener(this);
+    }
+
+    public IAdvertisingListener listener() {
+        return this.mListener.get();
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return this.mNext.isLoaded(str, str2, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        this.mNext.load(str, str2, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        this.mNext.show(str, str2, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
+        this.mListener.set(iAdvertisingListener);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        this.mNext.onAdvertisementImpression(str, str2, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        this.mNext.onAdvertisementClick(str, str2, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+        this.mNext.destroy();
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+        this.mNext.onPause();
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+        this.mNext.onResume();
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+        this.mNext.setUserIdentifier(str, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        this.mNext.discard(str, str2, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+        this.mNext.setCustomProperties(map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return this.mNext.getReward(str, str2);
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onCustomActionReceived(@NonNull CustomAction customAction) {
+        listener().onCustomActionReceived(customAction);
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onPlacementEvent(@NonNull PlacementEvent placementEvent) {
+        listener().onPlacementEvent(placementEvent);
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onRewardReceived(@NonNull Reward reward) {
+        listener().onRewardReceived(reward);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+        this.mNext.internal_setGemsData(str, map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+        this.mNext.internal_updatePrivacyStatus(privacyStatus);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(Map<String, Object> map) {
+        this.mNext.internal_updateRewardList(map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
+        this.mNext.internal_updateAdsFrequency(map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+        this.mNext.internal_onNewSession();
+    }
+}

decompiled/sources/csdk/gluads/impl/DestroyedAdvertising.java

@@ -0,0 +1,90 @@
+package csdk.gluads.impl;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+class DestroyedAdvertising implements IAdvertising {
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return null;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return false;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+}

decompiled/sources/csdk/gluads/impl/DisabledException.java

@@ -0,0 +1,5 @@
+package csdk.gluads.impl;
+
+/* loaded from: classes4.dex */
+public class DisabledException extends RuntimeException {
+}

decompiled/sources/csdk/gluads/impl/DummyAdvertising.java

@@ -0,0 +1,103 @@
+package csdk.gluads.impl;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.Consts;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class DummyAdvertising implements IAdvertising {
+    private final AtomicReference<IAdvertisingListener> listener = new AtomicReference<>(NullAdvertisingListener.INSTANCE);
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return null;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return false;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        this.listener.get().onPlacementEvent(new PlacementEvent(str, str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new UnsupportedOperationException("Dummy."), map));
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        this.listener.get().onPlacementEvent(new PlacementEvent(str, str2, Consts.PLACEMENT_STATUS_SHOW_FINISHED, new UnsupportedOperationException("Dummy."), map));
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
+        AtomicReference<IAdvertisingListener> atomicReference = this.listener;
+        if (iAdvertisingListener == null) {
+            iAdvertisingListener = NullAdvertisingListener.INSTANCE;
+        }
+        atomicReference.set(iAdvertisingListener);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+        this.listener.set(NullAdvertisingListener.INSTANCE);
+    }
+}

decompiled/sources/csdk/gluads/impl/IllegalConfigurationException.java

@@ -0,0 +1,11 @@
+package csdk.gluads.impl;
+
+/* loaded from: classes4.dex */
+public class IllegalConfigurationException extends RuntimeException {
+    public IllegalConfigurationException() {
+    }
+
+    public IllegalConfigurationException(String str) {
+        super(str);
+    }
+}

decompiled/sources/csdk/gluads/impl/NullAdvertisingListener.java

@@ -0,0 +1,24 @@
+package csdk.gluads.impl;
+
+import androidx.annotation.NonNull;
+import csdk.gluads.CustomAction;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.Reward;
+
+/* loaded from: classes4.dex */
+public class NullAdvertisingListener implements IAdvertisingListener {
+    public static final IAdvertisingListener INSTANCE = new NullAdvertisingListener();
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onCustomActionReceived(@NonNull CustomAction customAction) {
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onPlacementEvent(@NonNull PlacementEvent placementEvent) {
+    }
+
+    @Override // csdk.gluads.IAdvertisingListener
+    public void onRewardReceived(@NonNull Reward reward) {
+    }
+}

decompiled/sources/csdk/gluads/impl/QueuingAdvertising.java

@@ -0,0 +1,406 @@
+package csdk.gluads.impl;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.IAction1;
+import java.util.ArrayDeque;
+import java.util.Map;
+import java.util.Queue;
+
+/* loaded from: classes4.dex */
+public class QueuingAdvertising implements IAdvertising {
+    private IAdvertising mAdvertising;
+    private final Queue<IAction1<IAdvertising>> mQueue = new ArrayDeque();
+
+    public void delegateTo(@NonNull IAdvertising iAdvertising) {
+        IAdvertising iAdvertising2;
+        IAction1<IAdvertising> peek;
+        synchronized (this) {
+            try {
+                if (this.mAdvertising != null) {
+                    return;
+                }
+                this.mAdvertising = iAdvertising;
+                boolean z = true;
+                while (true) {
+                    synchronized (this) {
+                        if (!z) {
+                            try {
+                                this.mQueue.poll();
+                            } finally {
+                            }
+                        }
+                        if (this.mQueue.isEmpty()) {
+                            return;
+                        }
+                        iAdvertising2 = this.mAdvertising;
+                        peek = this.mQueue.peek();
+                    }
+                    peek.apply(iAdvertising2);
+                    z = false;
+                }
+            } finally {
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                IAdvertising iAdvertising = this.mAdvertising;
+                if (iAdvertising == null) {
+                    return false;
+                }
+                return iAdvertising.isLoaded(str, str2, map);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void load(@NonNull final String str, @NonNull final String str2, @Nullable Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    final Map shallowClone = Common.shallowClone(map);
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.1
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.load(str, str2, shallowClone);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.load(str, str2, map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void show(@NonNull final String str, @NonNull final String str2, @Nullable Map<String, Object> map) {
+        final Map<String, Object> shallowClone = Common.shallowClone(map);
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.2
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            QueuingAdvertising.this.internal_show(iAdvertising, str, str2, shallowClone);
+                        }
+                    });
+                } else {
+                    internal_show(this.mAdvertising, str, str2, shallowClone);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable final IAdvertisingListener iAdvertisingListener) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.3
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.setAdvertisingListener(iAdvertisingListener);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.setAdvertisingListener(iAdvertisingListener);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull final String str, @NonNull final String str2, @Nullable Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    final Map shallowClone = Common.shallowClone(map);
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.4
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.onAdvertisementImpression(str, str2, shallowClone);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.onAdvertisementImpression(str, str2, map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull final String str, @NonNull final String str2, @Nullable Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    final Map shallowClone = Common.shallowClone(map);
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.5
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.onAdvertisementClick(str, str2, shallowClone);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.onAdvertisementClick(str, str2, map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+        IAdvertising iAdvertising;
+        synchronized (this) {
+            iAdvertising = this.mAdvertising;
+            this.mAdvertising = new DestroyedAdvertising();
+            this.mQueue.clear();
+        }
+        if (iAdvertising != null) {
+            iAdvertising.destroy();
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.6
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.onPause();
+                        }
+                    });
+                } else {
+                    this.mAdvertising.onPause();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.7
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.onResume();
+                        }
+                    });
+                } else {
+                    this.mAdvertising.onResume();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable final String str, @Nullable Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    final Map shallowClone = Common.shallowClone(map);
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.8
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.setUserIdentifier(str, shallowClone);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.setUserIdentifier(str, map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(@NonNull final String str, @NonNull final String str2, @Nullable Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    final Map shallowClone = Common.shallowClone(map);
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.9
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.discard(str, str2, shallowClone);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.discard(str, str2, map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    final Map shallowClone = Common.shallowClone(map);
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.10
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.setCustomProperties(shallowClone);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.setCustomProperties(map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return this.mAdvertising.getReward(str, str2);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable final String str, @Nullable Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    final Map shallowClone = Common.shallowClone(map);
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.11
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.internal_setGemsData(str, shallowClone);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.internal_setGemsData(str, map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(final PrivacyStatus privacyStatus) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.12
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.internal_updatePrivacyStatus(privacyStatus);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.internal_updatePrivacyStatus(privacyStatus);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull final Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.13
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.internal_updateRewardList(map);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.internal_updateRewardList(map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull final Map<String, Object> map) {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.14
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.internal_updateAdsFrequency(map);
+                        }
+                    });
+                } else {
+                    this.mAdvertising.internal_updateAdsFrequency(map);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+        this.mAdvertising.internal_updateCrossPromotion(str, map, map2);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+        synchronized (this) {
+            try {
+                if (unsafe_shouldQueue()) {
+                    this.mQueue.add(new IAction1<IAdvertising>() { // from class: csdk.gluads.impl.QueuingAdvertising.15
+                        @Override // csdk.gluads.util.IAction1
+                        public void apply(IAdvertising iAdvertising) {
+                            iAdvertising.internal_onNewSession();
+                        }
+                    });
+                } else {
+                    this.mAdvertising.internal_onNewSession();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void internal_show(@NonNull IAdvertising iAdvertising, @NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        iAdvertising.show(str, str2, map);
+    }
+
+    private boolean unsafe_shouldQueue() {
+        return this.mAdvertising == null || !this.mQueue.isEmpty();
+    }
+}

decompiled/sources/csdk/gluads/impl/SuppressionRulesProxy.java

@@ -0,0 +1,232 @@
+package csdk.gluads.impl;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.applovin.impl.sdk.utils.JsonUtils;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import csdk.gluads.Consts;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.jsevaluator.JsEvaluator;
+import csdk.gluads.jsevaluator.interfaces.JsCallback;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.JsonUtil;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import csdk.gluads.util.log.YLoggers;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicLong;
+
+/* loaded from: classes4.dex */
+public class SuppressionRulesProxy extends AdvertisingProxy {
+    private static final List<String> SUPPORTED_AD_TYPES = Arrays.asList("interstitial", "banner");
+    private ConcurrentHashMap<String, Object> mCustomData;
+    private final boolean mDebug;
+    private final long mInitializationTimestamp;
+    private final Long mInstallTimestamp;
+    private JsEvaluator mJsEvaluator;
+    private AtomicLong mLastAdShownTimestamp;
+    private final String mSuppressionRules;
+    private final boolean mSuppressionRulesDisabled;
+    private String mSuppressionRulesEvaluatorJsScript;
+    private final YLogger mLog = YLoggerFactory.getLogger(getClass());
+    private final Object lock = new Object();
+
+    public SuppressionRulesProxy(Callable<Activity> callable, Map<String, Object> map, long j) {
+        final Context context = (Context) Common.call(callable);
+        this.mSuppressionRules = getSuppressionRulesFromConfig(map);
+        this.mDebug = ConfigUtil.getBoolean(map, "csdk.gluAds.debug.all");
+        this.mLastAdShownTimestamp = new AtomicLong(0L);
+        this.mInitializationTimestamp = j;
+        this.mInstallTimestamp = getFirstInstallTime(context);
+        this.mCustomData = new ConcurrentHashMap<>();
+        boolean z = ConfigUtil.getBoolean(ConfigUtil.getMap(map, "csdk.gluAds.disabled"), Consts.SUPPRESSION_RULES);
+        this.mSuppressionRulesDisabled = z;
+        if (z) {
+            return;
+        }
+        this.mSuppressionRulesEvaluatorJsScript = getSuppressionRulesJsScriptAsString(context);
+        Common.runOnUIThread(new Runnable() { // from class: csdk.gluads.impl.SuppressionRulesProxy.1
+            @Override // java.lang.Runnable
+            public void run() {
+                SuppressionRulesProxy.this.mJsEvaluator = new JsEvaluator(context);
+            }
+        });
+    }
+
+    @Override // csdk.gluads.impl.AdvertisingProxy, csdk.gluads.IAdvertising
+    public void load(@NonNull final String str, @NonNull final String str2, @Nullable final Map<String, Object> map) {
+        if (this.mSuppressionRulesDisabled || !SUPPORTED_AD_TYPES.contains(str)) {
+            super.load(str, str2, map);
+            return;
+        }
+        if (isLoaded(str, str2, map)) {
+            super.listener().onPlacementEvent(new PlacementEvent(str, str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, null, map));
+            return;
+        }
+        final String buildSuppressionRulesParameters = buildSuppressionRulesParameters();
+        final IAdvertising next = super.next();
+        final IAdvertisingListener listener = super.listener();
+        Common.runOnUIThread(new Runnable() { // from class: csdk.gluads.impl.SuppressionRulesProxy.2
+            @Override // java.lang.Runnable
+            public void run() {
+                SuppressionRulesProxy.this.mJsEvaluator.callFunction(SuppressionRulesProxy.this.mSuppressionRulesEvaluatorJsScript, new JsCallback() { // from class: csdk.gluads.impl.SuppressionRulesProxy.2.1
+                    @Override // csdk.gluads.jsevaluator.interfaces.JsCallback
+                    public void onResult(String str3) {
+                        if (Boolean.valueOf(str3).booleanValue()) {
+                            AnonymousClass2 anonymousClass2 = AnonymousClass2.this;
+                            next.load(str, str2, map);
+                        } else {
+                            AnonymousClass2 anonymousClass22 = AnonymousClass2.this;
+                            listener.onPlacementEvent(new PlacementEvent(str, str2, Consts.PLACEMENT_STATUS_LOAD_STARTED, new Exception("Load suppressed"), map));
+                        }
+                    }
+
+                    @Override // csdk.gluads.jsevaluator.interfaces.JsCallback
+                    public void onError(String str3) {
+                        SuppressionRulesProxy.this.mLog.w("SUPPRESSION_RULES.CHECK.FAILED", "l", ConfigUtil.getString(map, Consts.MEDIATION_NETWORK), InneractiveMediationDefs.GENDER_MALE, str3);
+                        AnonymousClass2 anonymousClass2 = AnonymousClass2.this;
+                        next.load(str, str2, map);
+                    }
+                }, "canLoadAd", str, SuppressionRulesProxy.this.mSuppressionRules, buildSuppressionRulesParameters, String.valueOf(SuppressionRulesProxy.this.mDebug));
+            }
+        });
+    }
+
+    @Override // csdk.gluads.impl.AdvertisingProxy, csdk.gluads.IAdvertising
+    public void show(@NonNull final String str, @NonNull final String str2, @Nullable final Map<String, Object> map) {
+        if (this.mSuppressionRulesDisabled || !SUPPORTED_AD_TYPES.contains(str)) {
+            super.show(str, str2, map);
+            return;
+        }
+        if (!isLoaded(str, str2, map)) {
+            super.listener().onPlacementEvent(new PlacementEvent(str, str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Not ready"), map));
+        } else {
+            final String buildSuppressionRulesParameters = buildSuppressionRulesParameters();
+            final IAdvertising next = super.next();
+            final IAdvertisingListener listener = super.listener();
+            Common.runOnUIThread(new Runnable() { // from class: csdk.gluads.impl.SuppressionRulesProxy.3
+                @Override // java.lang.Runnable
+                public void run() {
+                    SuppressionRulesProxy.this.mJsEvaluator.callFunction(SuppressionRulesProxy.this.mSuppressionRulesEvaluatorJsScript, new JsCallback() { // from class: csdk.gluads.impl.SuppressionRulesProxy.3.1
+                        @Override // csdk.gluads.jsevaluator.interfaces.JsCallback
+                        public void onResult(String str3) {
+                            if (Boolean.valueOf(str3).booleanValue()) {
+                                if (!str.equals("banner")) {
+                                    SuppressionRulesProxy.this.mLastAdShownTimestamp.set(System.currentTimeMillis());
+                                }
+                                AnonymousClass3 anonymousClass3 = AnonymousClass3.this;
+                                next.show(str, str2, map);
+                                return;
+                            }
+                            AnonymousClass3 anonymousClass32 = AnonymousClass3.this;
+                            listener.onPlacementEvent(new PlacementEvent(str, str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new Exception("Show suppressed"), map));
+                        }
+
+                        @Override // csdk.gluads.jsevaluator.interfaces.JsCallback
+                        public void onError(String str3) {
+                            SuppressionRulesProxy.this.mLog.w("SUPPRESSION_RULES.CHECK.FAILED", "l", ConfigUtil.getString(map, Consts.MEDIATION_NETWORK), InneractiveMediationDefs.GENDER_MALE, str3);
+                            AnonymousClass3 anonymousClass3 = AnonymousClass3.this;
+                            next.show(str, str2, map);
+                        }
+                    }, "canShowAd", str, SuppressionRulesProxy.this.mSuppressionRules, buildSuppressionRulesParameters, String.valueOf(SuppressionRulesProxy.this.mDebug));
+                }
+            });
+        }
+    }
+
+    @Override // csdk.gluads.impl.AdvertisingProxy, csdk.gluads.IAdvertising
+    public void destroy() {
+        if (!this.mSuppressionRulesDisabled) {
+            Common.runOnUIThread(new Runnable() { // from class: csdk.gluads.impl.SuppressionRulesProxy.4
+                @Override // java.lang.Runnable
+                public void run() {
+                    SuppressionRulesProxy.this.mJsEvaluator.destroy();
+                }
+            });
+        }
+        super.next().destroy();
+    }
+
+    @Override // csdk.gluads.impl.AdvertisingProxy, csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+        if (map == null) {
+            return;
+        }
+        synchronized (this.lock) {
+            this.mCustomData.putAll(map);
+        }
+        super.setCustomProperties(map);
+    }
+
+    private static String getSuppressionRulesJsScriptAsString(Context context) {
+        InputStream inputStream = null;
+        try {
+            inputStream = context.getAssets().open("js/SuppressionRulesEvaluator.js");
+            byte[] bArr = new byte[inputStream.available()];
+            inputStream.read(bArr);
+            inputStream.close();
+            String str = new String(bArr);
+            try {
+                inputStream.close();
+                return str;
+            } catch (IOException unused) {
+                return str;
+            }
+        } catch (IOException unused2) {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException unused3) {
+                }
+            }
+            return "";
+        } catch (Throwable th) {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (IOException unused4) {
+                }
+            }
+            throw th;
+        }
+    }
+
+    private String buildSuppressionRulesParameters() {
+        Map createMap = Common.createMap();
+        createMap.put("appInstallTimeInMs", this.mInstallTimestamp);
+        createMap.put("currentLaunchTimeInMs", Long.valueOf(this.mInitializationTimestamp));
+        createMap.put("currentTimeInMs", Long.valueOf(System.currentTimeMillis()));
+        createMap.put("lastAdDismissedTimeInMs", Long.valueOf(this.mLastAdShownTimestamp.get()));
+        createMap.putAll(this.mCustomData);
+        return JsonUtil.toJson(createMap);
+    }
+
+    private String getSuppressionRulesFromConfig(@NonNull Map<String, Object> map) {
+        if (this.mSuppressionRulesDisabled) {
+            YLoggers.sdkConfiguration(this.mLog, Consts.SUPPRESSION_RULES, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
+            return null;
+        }
+        Map<String, Object> map2 = ConfigUtil.getMap(map, "csdk.gluAds.suppressionRules");
+        return map2 != null ? JsonUtil.toJson(map2) : JsonUtils.EMPTY_JSON;
+    }
+
+    private Long getFirstInstallTime(Context context) {
+        try {
+            return Long.valueOf(context.getPackageManager().getPackageInfo(context.getPackageName(), 0).firstInstallTime);
+        } catch (PackageManager.NameNotFoundException unused) {
+            return null;
+        }
+    }
+}

decompiled/sources/csdk/gluads/ironsource/EAIronSource.java

@@ -0,0 +1,229 @@
+package csdk.gluads.ironsource;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Build;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.facebook.ads.AdSettings;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.google.android.gms.ads.RequestConfiguration;
+import com.ironsource.adqualitysdk.sdk.IronSourceAdQuality;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.integration.IntegrationHelper;
+import com.ironsource.mediationsdk.metadata.a;
+import com.ironsource.mediationsdk.sdk.InitializationListener;
+import com.ironsource.mediationsdk.utils.IronSourceUtils;
+import com.mbridge.msdk.MBridgeConstans;
+import com.mbridge.msdk.out.MBridgeSDKFactory;
+import com.mbridge.msdk.system.MBridgeSDKImpl;
+import csdk.gluads.Consts;
+import csdk.gluads.GluAdsFactory;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.impl.AdvertisingImpl;
+import csdk.gluads.impl.DummyAdvertising;
+import csdk.gluads.util.AdvertisingUtil;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.Futures;
+import csdk.gluads.util.IAction1;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import csdk.gluads.util.log.YLoggers;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes4.dex */
+public class EAIronSource {
+    private static final YLogger log = YLoggerFactory.getLogger((Class<?>) EAIronSource.class);
+    private static String mAdMobTestDeviceID = "";
+    private static Map<String, String> mAdapterNames;
+    private static Set<String> mDisabledAdapters;
+
+    static {
+        HashMap hashMap = new HashMap();
+        mAdapterNames = hashMap;
+        hashMap.put(Consts.SDK_APPLOVIN, "com.ironsource.adapters.applovin.AppLovinAdapter");
+        mAdapterNames.put(Consts.SDK_FACEBOOK_AUDIENCE_NETWORK, "com.ironsource.adapters.facebook.FacebookAdapter");
+        mAdapterNames.put(Consts.SDK_ADMOB, "com.ironsource.adapters.admob.AdMobAdapter");
+        mAdapterNames.put(Consts.SDK_UNITY_ADS, "com.ironsource.adapters.unityads.UnityAdsAdapter");
+        mAdapterNames.put(Consts.SDK_VUNGLE, "com.ironsource.adapters.vungle.VungleAdapter");
+    }
+
+    @NonNull
+    public static Future<?> createIronSource(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, final boolean z, PrivacyStatus privacyStatus, @NonNull AdvertisingImpl advertisingImpl, boolean z2) {
+        HashSet hashSet = new HashSet();
+        mDisabledAdapters = hashSet;
+        if (privacyStatus != null && (privacyStatus.underAgeUser || privacyStatus.teenUser)) {
+            hashSet.add(getAdapterClassName(Consts.SDK_APPLOVIN));
+        }
+        Map<String, Object> configDisabled = ConfigUtil.configDisabled(map);
+        final Activity activity = (Activity) Common.call(callable);
+        if (ConfigUtil.getBoolean(configDisabled, Consts.SDK_IRONSOURCE)) {
+            YLoggers.sdkConfiguration(log, Consts.SDK_IRONSOURCE, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_IRONSOURCE, "disabled", null, advertisingImpl);
+            return GluAdsFactory.disabledFuture();
+        }
+        int i = 0;
+        if (!AdvertisingUtil.isAPIEnabled()) {
+            YLoggers.sdkConfiguration(log, Consts.SDK_IRONSOURCE, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE, "DISABLE", "API", Consts.KEY_TAPJOY_USER_ID_VERSION, Integer.valueOf(Build.VERSION.SDK_INT));
+            if (z2) {
+                String[] strArr = Consts.SDK_ARRAY_AD_NETWORKS;
+                int length = strArr.length;
+                while (i < length) {
+                    AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, strArr[i], "disabled", null, advertisingImpl);
+                    i++;
+                }
+            } else {
+                AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_IRONSOURCE, "disabled", null, advertisingImpl);
+            }
+            return GluAdsFactory.disabledFuture();
+        }
+        advertisingImpl.updatePrivacyStage(Consts.SDK_IRONSOURCE, "started");
+        Map<String, Object> configSdk = ConfigUtil.configSdk(map);
+        final String string = ConfigUtil.getString(configSdk, "ironSource.appKey");
+        if (TextUtils.isEmpty(string)) {
+            YLoggers.sdkConfiguration(log, Consts.SDK_IRONSOURCE, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE, Consts.KEY_TAPJOY_USER_ID_VERSION, "IronSource AppKey is null or empty");
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_IRONSOURCE, "disabled", null, advertisingImpl);
+            return GluAdsFactory.disabledFuture();
+        }
+        final boolean z3 = ConfigUtil.getBoolean(configSdk, "ironSource.enableGoogleTestAds", false);
+        final AtomicBoolean atomicBoolean = new AtomicBoolean(false);
+        IAction1<PrivacyStatus> iAction1 = new IAction1<PrivacyStatus>() { // from class: csdk.gluads.ironsource.EAIronSource.1
+            @Override // csdk.gluads.util.IAction1
+            public void apply(final PrivacyStatus privacyStatus2) {
+                if (z) {
+                    IntegrationHelper.validateIntegration(activity);
+                    IronSource.setAdaptersDebug(true);
+                }
+                IronSource.setMetaData("AdMob_TFCD", privacyStatus2.underAgeUser ? "true" : "false");
+                IronSource.setMetaData("AdMob_TFUA", privacyStatus2.underAgeUser ? "true" : "false");
+                IronSource.setMetaData("AppLovin_AgeRestrictedUser", privacyStatus2.underAgeUser ? "true" : "false");
+                if (privacyStatus2.underAgeUser) {
+                    IronSource.setMetaData("DT_IsChild", "true");
+                    IronSource.setMetaData("DT_COPPA", "true");
+                }
+                if (privacyStatus2.gdprApplies) {
+                    IronSource.setConsent(privacyStatus2.hasConsent);
+                }
+                if (privacyStatus2.ccpaApplies) {
+                    IronSource.setMetaData(a.a, Boolean.toString(privacyStatus2.ccpaOptOut));
+                }
+                String bool = Boolean.toString(privacyStatus2.underAgeUser);
+                IronSource.setMetaData(a.c, bool);
+                IronSource.setMetaData(a.b, bool);
+                if (privacyStatus2.ccpaOptOut) {
+                    AdSettings.setDataProcessingOptions(new String[]{"LDU"}, 0, 0);
+                } else {
+                    AdSettings.setDataProcessingOptions(new String[0]);
+                }
+                IronSource.setMetaData("META_Mixed_Audience", privacyStatus2.underAgeUser ? "true" : "false");
+                IronSource.setMetaData("Mintegral_COPPA", privacyStatus2.underAgeUser ? "true" : "false");
+                IronSource.setMetaData("tapjoy_coppa", privacyStatus2.underAgeUser ? "true" : "false");
+                IronSource.setMetaData("Tapjoy_optOutAdvertisingID", privacyStatus2.underAgeUser ? "true" : "false");
+                IronSource.setMetaData("UnityAds_coppa", privacyStatus2.underAgeUser ? "true" : "false");
+                IronSource.setMetaData("Vungle_coppa", privacyStatus2.underAgeUser ? "true" : "false");
+                if (!atomicBoolean.get()) {
+                    atomicBoolean.set(true);
+                    IronSource.init(activity, string, new InitializationListener() { // from class: csdk.gluads.ironsource.EAIronSource.1.1
+                        @Override // com.ironsource.mediationsdk.sdk.InitializationListener
+                        public void onInitializationComplete() {
+                            MBridgeSDKImpl mBridgeSDK = MBridgeSDKFactory.getMBridgeSDK();
+                            Context applicationContext = activity.getApplicationContext();
+                            Boolean valueOf = Boolean.valueOf(privacyStatus2.hasConsent);
+                            if (valueOf != null) {
+                                boolean booleanValue = valueOf.booleanValue();
+                                mBridgeSDK.setUserPrivateInfoType(applicationContext, MBridgeConstans.AUTHORITY_ALL_INFO, booleanValue ? 1 : 0);
+                                mBridgeSDK.setConsentStatus(applicationContext, booleanValue ? 1 : 0);
+                            }
+                            Boolean valueOf2 = Boolean.valueOf(privacyStatus2.ccpaOptOut);
+                            if (valueOf2 != null && valueOf2.booleanValue()) {
+                                mBridgeSDK.setDoNotTrackStatus(applicationContext, true);
+                            }
+                            Boolean valueOf3 = Boolean.valueOf(privacyStatus2.underAgeUser);
+                            if (valueOf3 != null) {
+                                mBridgeSDK.setCoppaStatus(applicationContext, valueOf3.booleanValue());
+                            }
+                        }
+                    });
+                    EAIronSource.log.d("SDK.VERSION", Consts.SDK_IRONSOURCE, IronSourceUtils.getSDKVersion(), InneractiveMediationDefs.GENDER_MALE, "onSdkInitialized");
+                }
+                if (z || z3) {
+                    String unused = EAIronSource.mAdMobTestDeviceID = Common.getAdMobTestDeviceID(activity);
+                    IronSource.setMetaData(a.f, a.j);
+                }
+            }
+        };
+        IAction1<PrivacyStatus> iAction12 = new IAction1<PrivacyStatus>() { // from class: csdk.gluads.ironsource.EAIronSource.2
+            @Override // csdk.gluads.util.IAction1
+            public void apply(PrivacyStatus privacyStatus2) {
+            }
+        };
+        String[] strArr2 = Consts.SDK_ARRAY_AD_NETWORKS;
+        int length2 = strArr2.length;
+        while (i < length2) {
+            String str = strArr2[i];
+            if (ConfigUtil.getBoolean(configDisabled, str)) {
+                mDisabledAdapters.add(getAdapterClassName(str));
+            }
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, str, Consts.SDK_PRIVACY_STAGE_ADDED, TextUtils.equals(str, Consts.SDK_IRONSOURCE) ? iAction1 : iAction12, advertisingImpl);
+            i++;
+        }
+        YLogger yLogger = log;
+        yLogger.d("SDK.VERSION", Consts.SDK_IRONSOURCE, IronSourceUtils.getSDKVersion(), InneractiveMediationDefs.GENDER_MALE, "Initialization delayed");
+        YLoggers.sdkConfiguration(yLogger, Consts.SDK_IRONSOURCE, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.TRUE);
+        return Futures.successful(Consts.SDK_IRONSOURCE);
+    }
+
+    @NonNull
+    public static IAdvertising createIronSourceRewardedInterstitialManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, boolean z) {
+        Map<String, Object> configDisabled = ConfigUtil.configDisabled(map);
+        if (ConfigUtil.getBoolean(configDisabled, Consts.SDK_IRONSOURCE)) {
+            YLoggers.sdkConfiguration(log, Consts.SDK_IRONSOURCE, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
+            return new DummyAdvertising();
+        }
+        Map<String, Object> configSdk = ConfigUtil.configSdk(map);
+        return new EAIronSourceRVManager(callable, Common.mapSSFromConfig(ConfigUtil.getConfigMapVariant(configSdk, "ironSource.rewardedInterstitialPlacementMapping", z, null)), ConfigUtil.getMap(configSdk, "frequency", null), ConfigUtil.getString(configSdk, "ironSource.placementRewardSeparator", ","), ConfigUtil.getMap(configSdk, "ironSource.rewards"), ConfigUtil.shouldSendImpressionData(configDisabled), ConfigUtil.getBoolean(configDisabled, Consts.IS_LOADED_IGNORE_FREQUENCYCAPPING, false), ConfigUtil.getBoolean(configDisabled, Consts.GLOBAL_FREQUENCY_CAPPING, false));
+    }
+
+    @NonNull
+    public static IAdvertising createIronSourceInterstitialManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, boolean z) {
+        Map<String, Object> configDisabled = ConfigUtil.configDisabled(map);
+        if (ConfigUtil.getBoolean(configDisabled, Consts.SDK_IRONSOURCE)) {
+            YLoggers.sdkConfiguration(log, Consts.SDK_IRONSOURCE, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
+            return new DummyAdvertising();
+        }
+        Map<String, Object> configSdk = ConfigUtil.configSdk(map);
+        return new EAIronSourceInterstitialManager(callable, Common.mapSSFromConfig(ConfigUtil.getConfigMapVariant(configSdk, "ironSource.interstitialPlacementMapping", z, null)), ConfigUtil.getMap(configSdk, "frequency.interstitial", null), ConfigUtil.shouldSendImpressionData(configDisabled), ConfigUtil.getBoolean(configDisabled, Consts.IS_LOADED_IGNORE_FREQUENCYCAPPING, false));
+    }
+
+    public static RequestConfiguration.Builder onAdMobLoadRequest(RequestConfiguration.Builder builder) {
+        if (!TextUtils.isEmpty(mAdMobTestDeviceID)) {
+            builder.setTestDeviceIds(Arrays.asList(mAdMobTestDeviceID));
+        }
+        return builder;
+    }
+
+    public static boolean adapterDisabled(String str) {
+        return mDisabledAdapters.contains(str);
+    }
+
+    private static String getAdapterClassName(String str) {
+        return mAdapterNames.get(str);
+    }
+
+    public static void setAdQualityUserID(String str) {
+        if (str == null || str.length() <= 0) {
+            return;
+        }
+        IronSourceAdQuality.getInstance().changeUserId(str);
+        log.d("AdQuality setUserID", Consts.SDK_IRONSOURCE, str);
+    }
+}

decompiled/sources/csdk/gluads/ironsource/EAIronSourceInterstitialManager.java

@@ -0,0 +1,141 @@
+package csdk.gluads.ironsource;
+
+import android.app.Activity;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.adunit.adapter.utility.AdInfo;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.sdk.LevelPlayInterstitialListener;
+import csdk.gluads.Consts;
+import csdk.gluads.max.EAPlacementListener;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class EAIronSourceInterstitialManager extends EAIronSourceManagerBase {
+    private boolean mIsLoadedIgnoreFrequencyCapping;
+    private AtomicReference<IntListener> mListener;
+    private AtomicReference<String> mLoadingPlacement;
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase
+    public String adType() {
+        return "interstitial";
+    }
+
+    public class IntListener extends EAPlacementListener implements LevelPlayInterstitialListener {
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayInterstitialListener
+        public void onAdOpened(AdInfo adInfo) {
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayInterstitialListener
+        public void onAdShowSucceeded(AdInfo adInfo) {
+        }
+
+        public IntListener() {
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayInterstitialListener
+        public void onAdReady(AdInfo adInfo) {
+            EAIronSourceInterstitialManager eAIronSourceInterstitialManager = EAIronSourceInterstitialManager.this;
+            eAIronSourceInterstitialManager.sendPlacementEvent(eAIronSourceInterstitialManager.loadingPlacement(), Consts.PLACEMENT_STATUS_LOAD_FINISHED, null, null);
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayInterstitialListener
+        public void onAdLoadFailed(IronSourceError ironSourceError) {
+            IllegalStateException illegalStateException = new IllegalStateException("Failed to load ad: " + ironSourceError.toString());
+            EAIronSourceInterstitialManager eAIronSourceInterstitialManager = EAIronSourceInterstitialManager.this;
+            eAIronSourceInterstitialManager.sendPlacementEvent(eAIronSourceInterstitialManager.loadingPlacement(), Consts.PLACEMENT_STATUS_LOAD_FINISHED, illegalStateException, null);
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayInterstitialListener
+        public void onAdClosed(AdInfo adInfo) {
+            EAIronSourceInterstitialManager.this.frequencyController().increaseCount(false, showingPlacement());
+            EAIronSourceInterstitialManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, null, null);
+            setShowingPlacement("");
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayInterstitialListener
+        public void onAdShowFailed(IronSourceError ironSourceError, AdInfo adInfo) {
+            EAIronSourceInterstitialManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Failed to show ad: " + ironSourceError.toString()), null);
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayInterstitialListener
+        public void onAdClicked(AdInfo adInfo) {
+            EAIronSourceInterstitialManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_CLICKED, null, null);
+        }
+    }
+
+    public EAIronSourceInterstitialManager(Callable<Activity> callable, Map<String, String> map, Map<String, Object> map2, boolean z, boolean z2) {
+        super(callable, map, map2, z);
+        this.mLoadingPlacement = new AtomicReference<>();
+        AtomicReference<IntListener> atomicReference = new AtomicReference<>(new IntListener());
+        this.mListener = atomicReference;
+        IronSource.setLevelPlayInterstitialListener(atomicReference.get());
+        this.mIsLoadedIgnoreFrequencyCapping = z2;
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase
+    public void setShowingPlacement(String str) {
+        IntListener intListener = this.mListener.get();
+        if (intListener != null) {
+            intListener.setShowingPlacement(str);
+        }
+        super.setShowingPlacement(str);
+    }
+
+    public String loadingPlacement() {
+        return this.mLoadingPlacement.get();
+    }
+
+    public void setLoadingPlacement(String str) {
+        this.mLoadingPlacement.set(str);
+    }
+
+    private boolean isCapped(@NonNull String str) {
+        return frequencyController().isLimitReached(str) || IronSource.isInterstitialPlacementCapped(str);
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void destroy() {
+        IronSource.setLevelPlayInterstitialListener(null);
+        super.destroy();
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return IronSource.isInterstitialReady() && (this.mIsLoadedIgnoreFrequencyCapping || !isCapped(str2));
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        if (str2.equals("IS_debugger")) {
+            IronSource.launchTestSuite(this.mActivity.getApplicationContext());
+            return;
+        }
+        if (frequencyController().isLimitReached(str2)) {
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalArgumentException("FrequencyCap limit."), map);
+        } else if (isLoaded(str, str2, map)) {
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, null, map);
+        } else {
+            setLoadingPlacement(str2);
+            IronSource.loadInterstitial();
+        }
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        if (str2.equals("IS_debugger")) {
+            IronSource.launchTestSuite(this.mActivity.getApplicationContext());
+        } else {
+            if (!isLoaded(adType(), str2, map)) {
+                sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Not ready"), null);
+                return;
+            }
+            setShowingPlacement(str2);
+            this.mLog.d("INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "l", Consts.SDK_IRONSOURCE);
+            IronSource.showInterstitial(str2);
+        }
+    }
+}

decompiled/sources/csdk/gluads/ironsource/EAIronSourceManagerBase.java

@@ -0,0 +1,292 @@
+package csdk.gluads.ironsource;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.ironsource.adqualitysdk.sdk.ISAdQualityAdType;
+import com.ironsource.adqualitysdk.sdk.ISAdQualityCustomMediationRevenue;
+import com.ironsource.adqualitysdk.sdk.ISAdQualityMediationNetwork;
+import com.ironsource.adqualitysdk.sdk.IronSourceAdQuality;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.impressionData.ImpressionData;
+import com.ironsource.mediationsdk.impressionData.ImpressionDataListener;
+import com.ironsource.nb;
+import csdk.gluads.Consts;
+import csdk.gluads.FrequencyController;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import csdk.gluads.impl.NullAdvertisingListener;
+import csdk.gluads.max.EAPlacementListener;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.JsonUtil;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class EAIronSourceManagerBase implements IAdvertising {
+    protected final Activity mActivity;
+    private final AtomicReference<FrequencyController> mFrequencyController;
+    private EAIronSourceImpressionListener mImpressionDataListener;
+    private final LifecycleListener mLCListener;
+    private final AtomicReference<IAdvertisingListener> mListener;
+    protected final YLogger mLog = YLoggerFactory.getLogger(getClass());
+    private final Map<String, String> mPlacementToAdUnitId;
+
+    public String adType() {
+        return null;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return null;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return false;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    public class LifecycleListener implements Application.ActivityLifecycleCallbacks {
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle bundle) {
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityDestroyed(@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) {
+        }
+
+        private LifecycleListener() {
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityResumed(@NonNull Activity activity) {
+            if (activity.getClass().getName().startsWith("com.ironsource.sdk")) {
+                return;
+            }
+            IronSource.onResume(activity);
+        }
+
+        @Override // android.app.Application.ActivityLifecycleCallbacks
+        public void onActivityPaused(@NonNull Activity activity) {
+            if (activity.getClass().getName().startsWith("com.ironsource.sdk")) {
+                return;
+            }
+            IronSource.onPause(activity);
+        }
+    }
+
+    public class EAIronSourceImpressionListener extends EAPlacementListener implements ImpressionDataListener {
+        final ISAdQualityAdType mAdType;
+        final String mAdUnitAccept;
+        final boolean mSendImpressionData;
+
+        public EAIronSourceImpressionListener(boolean z, String str) {
+            this.mSendImpressionData = z;
+            this.mAdUnitAccept = str;
+            this.mAdType = TextUtils.equals(EAIronSourceManagerBase.this.adType(), Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL) ? ISAdQualityAdType.REWARDED_VIDEO : ISAdQualityAdType.INTERSTITIAL;
+        }
+
+        @Override // com.ironsource.mediationsdk.impressionData.ImpressionDataListener
+        public void onImpressionSuccess(ImpressionData impressionData) {
+            if (impressionData.getAdUnit().equals(this.mAdUnitAccept)) {
+                sendImpressionInternal(impressionData);
+                sendImpressionSingular(impressionData);
+                sendImpressionToAdQuality(impressionData);
+            }
+        }
+
+        private void sendImpressionToAdQuality(ImpressionData impressionData) {
+            if (this.mSendImpressionData) {
+                IronSourceAdQuality.getInstance().sendCustomMediationRevenue(new ISAdQualityCustomMediationRevenue.Builder().setMediationNetwork(ISAdQualityMediationNetwork.SELF_MEDIATED).setAdType(this.mAdType).setPlacement(impressionData.getPlacement()).setRevenue(impressionData.getRevenue().doubleValue()).build());
+            }
+        }
+
+        private void sendImpressionInternal(ImpressionData impressionData) {
+            Map<String, Object> createMap = Common.createMap();
+            if (this.mSendImpressionData) {
+                createMap = JsonUtil.toMap(impressionData.getAllData());
+                Double revenue = impressionData.getRevenue();
+                if (revenue != null) {
+                    createMap.put(Consts.KEY_NAME_PUB_REVENUE, revenue);
+                    createMap.remove(ImpressionData.IMPRESSION_DATA_KEY_REVENUE);
+                }
+                if (!TextUtils.isEmpty(impressionData.getPlacement())) {
+                    createMap.put("adUnit", impressionData.getPlacement());
+                }
+            }
+            EAIronSourceManagerBase.this.mLog.d(EAIronSourceManagerBase.this.adType() + ".AD_IMPRESSION", nb.q, showingPlacement(), "l", Consts.SDK_IRONSOURCE, "extra", createMap);
+            EAIronSourceManagerBase.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_STARTED, null, createMap);
+        }
+
+        private void sendImpressionSingular(ImpressionData impressionData) {
+            if (this.mSendImpressionData) {
+                Map<String, Object> createMap = Common.createMap();
+                createMap.put("ad_platform", "IronSource");
+                createMap.put("ad_currency", "USD");
+                createMap.put("ad_revenue", impressionData.getRevenue());
+                createMap.put("withAdUnitId", impressionData.getInstanceId());
+                createMap.put("withAdUnitName", impressionData.getInstanceName());
+                createMap.put("withImpressionId", impressionData.getAuctionId());
+                createMap.put("withNetworkName", impressionData.getAdNetwork());
+                createMap.put("withAdPlacementName", impressionData.getPlacement());
+                createMap.put("withAdType", impressionData.getAdUnit());
+                EAIronSourceManagerBase.this.sendPlacementEvent(showingPlacement(), Consts.SINGULAR_AD_REVENUE_REPORT, null, createMap);
+            }
+        }
+    }
+
+    public EAIronSourceManagerBase(Callable<Activity> callable, Map<String, String> map, Map<String, Object> map2, boolean z) {
+        Activity activity = (Activity) Common.call(callable);
+        this.mActivity = activity;
+        this.mListener = new AtomicReference<>(NullAdvertisingListener.INSTANCE);
+        this.mFrequencyController = new AtomicReference<>(new FrequencyController(adType(), activity.getApplicationContext(), map2));
+        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
+        this.mPlacementToAdUnitId = concurrentHashMap;
+        if (map != null) {
+            synchronized (concurrentHashMap) {
+                concurrentHashMap.putAll(map);
+            }
+        }
+        String str = "";
+        if (adType().equals("interstitial")) {
+            str = "interstitial";
+        } else if (adType().equals(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
+            str = "rewarded_video";
+        }
+        EAIronSourceImpressionListener eAIronSourceImpressionListener = new EAIronSourceImpressionListener(z, str);
+        this.mImpressionDataListener = eAIronSourceImpressionListener;
+        IronSource.addImpressionDataListener(eAIronSourceImpressionListener);
+        LifecycleListener lifecycleListener = new LifecycleListener();
+        this.mLCListener = lifecycleListener;
+        activity.getApplication().registerActivityLifecycleCallbacks(lifecycleListener);
+    }
+
+    public IAdvertisingListener listener() {
+        return this.mListener.get();
+    }
+
+    public void setShowingPlacement(String str) {
+        this.mImpressionDataListener.setShowingPlacement(str);
+    }
+
+    public FrequencyController frequencyController() {
+        return this.mFrequencyController.get();
+    }
+
+    public void sendPlacementEvent(String str, String str2, Throwable th, Map<String, Object> map) {
+        if (th != null) {
+            this.mLog.e(adType() + Consts.STRING_PERIOD + str2, nb.q, str, "l", Consts.SDK_IRONSOURCE, "error", th);
+        } else {
+            this.mLog.d(adType() + Consts.STRING_PERIOD + str2, nb.q, str, "l", Consts.SDK_IRONSOURCE, "extra", map);
+        }
+        Map createMap = Common.createMap();
+        createMap.put(Consts.MEDIATION_NETWORK, Consts.SDK_IRONSOURCE);
+        if (map != null) {
+            createMap.putAll(map);
+        }
+        listener().onPlacementEvent(new PlacementEvent(adType(), str, str2, th, createMap));
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
+        AtomicReference<IAdvertisingListener> atomicReference = this.mListener;
+        if (iAdvertisingListener == null) {
+            iAdvertisingListener = NullAdvertisingListener.INSTANCE;
+        }
+        atomicReference.set(iAdvertisingListener);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+        this.mListener.set(NullAdvertisingListener.INSTANCE);
+        EAIronSourceImpressionListener eAIronSourceImpressionListener = this.mImpressionDataListener;
+        if (eAIronSourceImpressionListener != null) {
+            IronSource.removeImpressionDataListener(eAIronSourceImpressionListener);
+            this.mImpressionDataListener = null;
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
+        frequencyController().update(map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+        frequencyController().onNewSession();
+    }
+}

decompiled/sources/csdk/gluads/ironsource/EAIronSourceRVManager.java

@@ -0,0 +1,286 @@
+package csdk.gluads.ironsource;
+
+import android.app.Activity;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.share.internal.ShareConstants;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.adunit.adapter.utility.AdInfo;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.model.Placement;
+import com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoListener;
+import com.ironsource.nb;
+import csdk.gluads.Consts;
+import csdk.gluads.FrequencyController;
+import csdk.gluads.GemsDataUtil;
+import csdk.gluads.Reward;
+import csdk.gluads.max.EAPlacementListener;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.JsonUtil;
+import csdk.gluads.util.PlacementInfo;
+import csdk.gluads.util.RewardUtil;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class EAIronSourceRVManager extends EAIronSourceManagerBase {
+    private AtomicReference<String> mEncodedUserID;
+    private AtomicReference<String> mGemsData;
+    private boolean mIsLoadedIgnoreFrequencyCapping;
+    private AtomicReference<RVListener> mListener;
+    private final AtomicReference<String> mRewardSource;
+    private final Map<String, Object> mRewards;
+    private final String mSeparator;
+    private boolean mShouldIgnoreGlobalFrequencyCapping;
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase
+    public String adType() {
+        return Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL;
+    }
+
+    public class RVListener extends EAPlacementListener implements LevelPlayRewardedVideoListener {
+        private final AtomicReference<FrequencyController> mFrequencyController;
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoListener
+        public void onAdAvailable(AdInfo adInfo) {
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
+        public void onAdOpened(AdInfo adInfo) {
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoListener
+        public void onAdUnavailable() {
+        }
+
+        public RVListener(FrequencyController frequencyController) {
+            this.mFrequencyController = new AtomicReference<>(frequencyController);
+        }
+
+        private FrequencyController frequencyController() {
+            return this.mFrequencyController.get();
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
+        public void onAdClosed(AdInfo adInfo) {
+            frequencyController().increaseCount(false, showingPlacement());
+            EAIronSourceRVManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, null, null);
+            setShowingPlacement("");
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
+        public void onAdRewarded(Placement placement, AdInfo adInfo) {
+            EAIronSourceRVManager.this.mLog.d("REWARDED_INTERSTITIAL.REWARD", nb.q, showingPlacement(), "reward", placement);
+            if (placement == null) {
+                EAIronSourceRVManager.this.sendReward("unknown", 0, showingPlacement());
+            } else {
+                EAIronSourceRVManager.this.sendReward(placement.getRewardName(), placement.getRewardAmount(), showingPlacement());
+            }
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
+        public void onAdShowFailed(IronSourceError ironSourceError, AdInfo adInfo) {
+            EAIronSourceRVManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, new IllegalStateException("Failed to show ad: " + ironSourceError.toString()), null);
+            setShowingPlacement("");
+        }
+
+        @Override // com.ironsource.mediationsdk.sdk.LevelPlayRewardedVideoBaseListener
+        public void onAdClicked(Placement placement, AdInfo adInfo) {
+            EAIronSourceRVManager.this.sendPlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_CLICKED, null, null);
+        }
+    }
+
+    public EAIronSourceRVManager(Callable<Activity> callable, Map<String, String> map, Map<String, Object> map2, String str, Map<String, Object> map3, boolean z, boolean z2, boolean z3) {
+        super(callable, map, map2, z);
+        this.mGemsData = new AtomicReference<>();
+        this.mEncodedUserID = new AtomicReference<>();
+        this.mSeparator = str;
+        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
+        this.mRewards = concurrentHashMap;
+        AtomicReference<String> atomicReference = new AtomicReference<>("DEFAULT");
+        this.mRewardSource = atomicReference;
+        if (map3 != null) {
+            synchronized (concurrentHashMap) {
+                concurrentHashMap.putAll(map3);
+            }
+            atomicReference.set(map3.isEmpty() ? "DEFAULT" : "SDK (client)");
+        }
+        AtomicReference<RVListener> atomicReference2 = new AtomicReference<>(new RVListener(frequencyController()));
+        this.mListener = atomicReference2;
+        IronSource.setLevelPlayRewardedVideoListener(atomicReference2.get());
+        this.mIsLoadedIgnoreFrequencyCapping = z2;
+        this.mShouldIgnoreGlobalFrequencyCapping = z3;
+        if (z3) {
+            return;
+        }
+        frequencyController().enableGlobalFrequencyCapping();
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase
+    public void setShowingPlacement(String str) {
+        RVListener rVListener = this.mListener.get();
+        if (rVListener != null) {
+            rVListener.setShowingPlacement(str);
+        }
+        super.setShowingPlacement(str);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void sendReward(String str, int i, String str2) {
+        listener().onRewardReceived(new Reward(Common.uuid(), str2, Consts.SDK_IRONSOURCE, adType(), str, i));
+    }
+
+    private boolean isCapped(@NonNull String str) {
+        return frequencyController().isLimitReached(str) || IronSource.isRewardedVideoPlacementCapped(str);
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void destroy() {
+        IronSource.setLevelPlayRewardedVideoListener(null);
+        super.destroy();
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        Object obj;
+        synchronized (this.mRewards) {
+            obj = this.mRewards.get(str2);
+        }
+        if (obj == null || !(obj instanceof Map)) {
+            return null;
+        }
+        return RewardUtil.toReward(str2, obj);
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return IronSource.isRewardedVideoAvailable() && !TextUtils.isEmpty(this.mGemsData.get()) && (this.mIsLoadedIgnoreFrequencyCapping || !isCapped(str2));
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+        synchronized (this.mRewards) {
+            this.mRewards.clear();
+            this.mRewards.putAll(map);
+        }
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+        this.mLog.d("REWARDED_INTERSTITIAL.SET.GEMSDATA", Consts.KEY_TAPJOY_USER_ID_VERSION, str, "l", Consts.SDK_IRONSOURCE);
+        if (str != null) {
+            this.mGemsData.set(GemsDataUtil.base64Encode(str));
+            String tryGetPlayerId = tryGetPlayerId(str);
+            if (TextUtils.isEmpty(tryGetPlayerId)) {
+                EAIronSource.setAdQualityUserID(str);
+                return;
+            }
+            EAIronSource.setAdQualityUserID(tryGetPlayerId);
+            Map createMap = Common.createMap();
+            createMap.put("playerId", tryGetPlayerId);
+            this.mEncodedUserID.set(GemsDataUtil.base64Encode(JsonUtil.toJson(createMap)));
+        }
+    }
+
+    private String tryGetPlayerId(String str) {
+        try {
+            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
+            if (parseJsonObject != null) {
+                String string = ConfigUtil.getString(parseJsonObject, "playerId", "");
+                if (!TextUtils.isEmpty(string)) {
+                    return string;
+                }
+            }
+        } catch (Throwable th) {
+            this.mLog.d("REWARDED_INTERSTITIAL.TRYGETPLAYERID", "e", th, "l", Consts.SDK_IRONSOURCE);
+        }
+        return "";
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        this.mGemsData.set(str);
+        this.mEncodedUserID.set(str);
+        String tryGetPlayerId = tryGetPlayerId(str);
+        if (!TextUtils.isEmpty(tryGetPlayerId)) {
+            str = tryGetPlayerId;
+        }
+        EAIronSource.setAdQualityUserID(str);
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        IllegalArgumentException illegalArgumentException;
+        if (str2.equals("IS_debugger")) {
+            IronSource.launchTestSuite(this.mActivity.getApplicationContext());
+            return;
+        }
+        if (frequencyController().isLimitReached(str2)) {
+            illegalArgumentException = new IllegalArgumentException("FrequencyCap limit.");
+            if (frequencyController().isFreqCountRefreshRequired(str2)) {
+                if (map == null) {
+                    map = Common.createMap();
+                }
+                map.put(Consts.KEY_NAME_FREQUENCY_REFRESH, new Boolean(true));
+            }
+        } else {
+            illegalArgumentException = TextUtils.isEmpty(this.mGemsData.get()) ? new IllegalArgumentException("GemsData is empty.") : !isLoaded(str, str2, map) ? new IllegalArgumentException("No ads available.") : null;
+        }
+        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, illegalArgumentException, map);
+    }
+
+    @Override // csdk.gluads.ironsource.EAIronSourceManagerBase, csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        if (str2.equals("IS_debugger")) {
+            IronSource.launchTestSuite(this.mActivity.getApplicationContext());
+            return;
+        }
+        if (frequencyController().isLimitReached(str2)) {
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalArgumentException("FrequencyCap limit."), null);
+            return;
+        }
+        if (!isLoaded(adType(), str2, map)) {
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Not ready"), null);
+            return;
+        }
+        Map createMap = Common.createMap();
+        AtomicReference<String> atomicReference = this.mGemsData;
+        if (atomicReference != null) {
+            createMap.put(Consts.KEY_NAME_GEMSDATA, atomicReference.get());
+        }
+        if (map != null) {
+            String string = ConfigUtil.getString(map, Consts.MEDIATION_CUSTOM_DATA);
+            if (!TextUtils.isEmpty(string)) {
+                createMap.put(Consts.KEY_NAME_GAMEDATA, GemsDataUtil.base64Encode(string));
+            }
+        }
+        IronSource.clearRewardedVideoServerParameters();
+        IronSource.setRewardedVideoServerParameters(createMap);
+        String str3 = this.mEncodedUserID.get();
+        if (str3.length() < 128) {
+            IronSource.setDynamicUserId(str3);
+        } else {
+            this.mLog.d("REWARDED_INTERSTITIAL.SHOW", "e", "Dynamic user ID exceeds max length.", "l", Consts.SDK_IRONSOURCE);
+        }
+        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_ATTEMPT, null, map);
+        setShowingPlacement(str2);
+        PlacementInfo placement = RewardUtil.getPlacement(new PlacementInfo(this.mRewardSource.get(), str2), this.mRewards, map, this.mSeparator);
+        String str4 = placement.mName;
+        this.mLog.d("REWARDED_INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str4, ShareConstants.FEED_SOURCE_PARAM, placement.mSource, "l", Consts.SDK_IRONSOURCE);
+        if (IronSource.getRewardedVideoPlacementInfo(str4) == null) {
+            Exception exc = new Exception("No reward");
+            this.mLog.e("REWARDED_INTERSTITIAL.SHOW.ERROR", nb.q, str2, "l", Consts.SDK_IRONSOURCE, "e", exc);
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, exc, map);
+        } else {
+            this.mLog.d("REWARDED_INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str4, "l", Consts.SDK_IRONSOURCE);
+            IronSource.showRewardedVideo(str4);
+        }
+    }
+}

decompiled/sources/csdk/gluads/jsevaluator/HandlerWrapper.java

@@ -0,0 +1,14 @@
+package csdk.gluads.jsevaluator;
+
+import android.os.Handler;
+import csdk.gluads.jsevaluator.interfaces.HandlerWrapperInterface;
+
+/* loaded from: classes4.dex */
+public class HandlerWrapper implements HandlerWrapperInterface {
+    private final Handler mHandler = new Handler();
+
+    @Override // csdk.gluads.jsevaluator.interfaces.HandlerWrapperInterface
+    public void post(Runnable runnable) {
+        this.mHandler.post(runnable);
+    }
+}

decompiled/sources/csdk/gluads/jsevaluator/JavaScriptInterface.java

@@ -0,0 +1,18 @@
+package csdk.gluads.jsevaluator;
+
+import android.webkit.JavascriptInterface;
+import csdk.gluads.jsevaluator.interfaces.CallJavaResultInterface;
+
+/* loaded from: classes4.dex */
+public class JavaScriptInterface {
+    private final CallJavaResultInterface mCallJavaResultInterface;
+
+    public JavaScriptInterface(CallJavaResultInterface callJavaResultInterface) {
+        this.mCallJavaResultInterface = callJavaResultInterface;
+    }
+
+    @JavascriptInterface
+    public void returnResultToJava(String str, int i) {
+        this.mCallJavaResultInterface.jsCallFinished(str, Integer.valueOf(i));
+    }
+}

decompiled/sources/csdk/gluads/jsevaluator/JsEvaluator.java

@@ -0,0 +1,119 @@
+package csdk.gluads.jsevaluator;
+
+import android.content.Context;
+import android.webkit.WebView;
+import csdk.gluads.jsevaluator.interfaces.CallJavaResultInterface;
+import csdk.gluads.jsevaluator.interfaces.HandlerWrapperInterface;
+import csdk.gluads.jsevaluator.interfaces.JsCallback;
+import csdk.gluads.jsevaluator.interfaces.JsEvaluatorInterface;
+import csdk.gluads.jsevaluator.interfaces.WebViewWrapperInterface;
+import java.util.ArrayList;
+
+/* loaded from: classes4.dex */
+public class JsEvaluator implements CallJavaResultInterface, JsEvaluatorInterface {
+    private static final String JS_ERROR_PREFIX = "evgeniiJsEvaluatorException";
+    public static final String JS_NAMESPACE = "evgeniiJsEvaluator";
+    private final Context mContext;
+    protected WebViewWrapperInterface mWebViewWrapper;
+    private final ArrayList<JsCallback> mResultCallbacks = new ArrayList<>();
+    private HandlerWrapperInterface mHandler = new HandlerWrapper();
+
+    public ArrayList<JsCallback> getResultCallbacks() {
+        return this.mResultCallbacks;
+    }
+
+    public void setHandler(HandlerWrapperInterface handlerWrapperInterface) {
+        this.mHandler = handlerWrapperInterface;
+    }
+
+    public void setWebViewWrapper(WebViewWrapperInterface webViewWrapperInterface) {
+        this.mWebViewWrapper = webViewWrapperInterface;
+    }
+
+    public JsEvaluator(Context context) {
+        this.mContext = context;
+    }
+
+    public static String escapeCarriageReturn(String str) {
+        return str.replace("\r", "\\r");
+    }
+
+    public static String escapeClosingScript(String str) {
+        return str.replace("</", "<\\/");
+    }
+
+    public static String escapeNewLines(String str) {
+        return str.replace("\n", "\\n");
+    }
+
+    public static String escapeSingleQuotes(String str) {
+        return str.replace("'", "\\'");
+    }
+
+    public static String escapeSlash(String str) {
+        return str.replace("\\", "\\\\");
+    }
+
+    public static String getJsForEval(String str, int i) {
+        return String.format("%s.returnResultToJava(eval('try{%s}catch(e){\"%s\"+e}'), %s);", JS_NAMESPACE, escapeCarriageReturn(escapeNewLines(escapeClosingScript(escapeSingleQuotes(escapeSlash(str))))), JS_ERROR_PREFIX, Integer.valueOf(i));
+    }
+
+    @Override // csdk.gluads.jsevaluator.interfaces.JsEvaluatorInterface
+    public void callFunction(String str, JsCallback jsCallback, String str2, Object... objArr) {
+        evaluate(str + "; " + JsFunctionCallFormatter.toString(str2, objArr), jsCallback);
+    }
+
+    @Override // csdk.gluads.jsevaluator.interfaces.JsEvaluatorInterface
+    public void evaluate(String str) {
+        evaluate(str, null);
+    }
+
+    @Override // csdk.gluads.jsevaluator.interfaces.JsEvaluatorInterface
+    public void evaluate(String str, JsCallback jsCallback) {
+        int size = this.mResultCallbacks.size();
+        if (jsCallback == null) {
+            size = -1;
+        }
+        String jsForEval = getJsForEval(str, size);
+        if (jsCallback != null) {
+            this.mResultCallbacks.add(jsCallback);
+        }
+        getWebViewWrapper().loadJavaScript(jsForEval);
+    }
+
+    @Override // csdk.gluads.jsevaluator.interfaces.JsEvaluatorInterface
+    public void destroy() {
+        getWebViewWrapper().destroy();
+    }
+
+    @Override // csdk.gluads.jsevaluator.interfaces.JsEvaluatorInterface
+    public WebView getWebView() {
+        return getWebViewWrapper().getWebView();
+    }
+
+    public WebViewWrapperInterface getWebViewWrapper() {
+        if (this.mWebViewWrapper == null) {
+            this.mWebViewWrapper = new WebViewWrapper(this.mContext, this);
+        }
+        return this.mWebViewWrapper;
+    }
+
+    @Override // csdk.gluads.jsevaluator.interfaces.CallJavaResultInterface
+    public void jsCallFinished(final String str, Integer num) {
+        if (num.intValue() == -1) {
+            return;
+        }
+        final JsCallback jsCallback = this.mResultCallbacks.get(num.intValue());
+        this.mHandler.post(new Runnable() { // from class: csdk.gluads.jsevaluator.JsEvaluator.1
+            @Override // java.lang.Runnable
+            public void run() {
+                String str2 = str;
+                if (str2 != null && str2.startsWith(JsEvaluator.JS_ERROR_PREFIX)) {
+                    jsCallback.onError(str.substring(27));
+                } else {
+                    jsCallback.onResult(str);
+                }
+            }
+        });
+    }
+}

decompiled/sources/csdk/gluads/jsevaluator/JsFunctionCallFormatter.java

@@ -0,0 +1,27 @@
+package csdk.gluads.jsevaluator;
+
+/* loaded from: classes4.dex */
+public class JsFunctionCallFormatter {
+    public static String paramToString(Object obj) {
+        if (obj instanceof String) {
+            return String.format("\"%s\"", ((String) obj).replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n"));
+        }
+        try {
+            obj.toString();
+            return obj.toString();
+        } catch (NumberFormatException unused) {
+            return "";
+        }
+    }
+
+    public static String toString(String str, Object... objArr) {
+        StringBuilder sb = new StringBuilder();
+        for (Object obj : objArr) {
+            if (sb.length() > 0) {
+                sb.append(", ");
+            }
+            sb.append(paramToString(obj));
+        }
+        return String.format("%s(%s)", str, sb);
+    }
+}

decompiled/sources/csdk/gluads/jsevaluator/WebViewWrapper.java

@@ -0,0 +1,64 @@
+package csdk.gluads.jsevaluator;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.util.Base64;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import com.ironsource.nb;
+import com.unity3d.ads.adplayer.AndroidWebViewClient;
+import csdk.gluads.jsevaluator.interfaces.CallJavaResultInterface;
+import csdk.gluads.jsevaluator.interfaces.WebViewWrapperInterface;
+import java.io.UnsupportedEncodingException;
+
+@SuppressLint({"SetJavaScriptEnabled"})
+/* loaded from: classes4.dex */
+public class WebViewWrapper implements WebViewWrapperInterface {
+    protected WebView mWebView;
+
+    @Override // csdk.gluads.jsevaluator.interfaces.WebViewWrapperInterface
+    public WebView getWebView() {
+        return this.mWebView;
+    }
+
+    public WebViewWrapper(Context context, CallJavaResultInterface callJavaResultInterface) {
+        try {
+            WebView webView = new WebView(context);
+            this.mWebView = webView;
+            webView.setWillNotDraw(true);
+            WebSettings settings = this.mWebView.getSettings();
+            settings.setJavaScriptEnabled(true);
+            settings.setDefaultTextEncodingName(nb.N);
+            this.mWebView.addJavascriptInterface(new JavaScriptInterface(callJavaResultInterface), JsEvaluator.JS_NAMESPACE);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override // csdk.gluads.jsevaluator.interfaces.WebViewWrapperInterface
+    public void loadJavaScript(String str) {
+        if (this.mWebView != null) {
+            try {
+                String encodeToString = Base64.encodeToString(("<script>" + str + "</script>").getBytes("UTF-8"), 0);
+                this.mWebView.loadUrl("data:text/html;charset=utf-8;base64," + encodeToString);
+            } catch (UnsupportedEncodingException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override // csdk.gluads.jsevaluator.interfaces.WebViewWrapperInterface
+    public void destroy() {
+        WebView webView = this.mWebView;
+        if (webView != null) {
+            webView.removeJavascriptInterface(JsEvaluator.JS_NAMESPACE);
+            this.mWebView.loadUrl(AndroidWebViewClient.BLANK_PAGE);
+            this.mWebView.stopLoading();
+            this.mWebView.clearHistory();
+            this.mWebView.removeAllViews();
+            this.mWebView.destroyDrawingCache();
+            this.mWebView.destroy();
+            this.mWebView = null;
+        }
+    }
+}

decompiled/sources/csdk/gluads/jsevaluator/interfaces/CallJavaResultInterface.java

@@ -0,0 +1,6 @@
+package csdk.gluads.jsevaluator.interfaces;
+
+/* loaded from: classes4.dex */
+public interface CallJavaResultInterface {
+    void jsCallFinished(String str, Integer num);
+}

decompiled/sources/csdk/gluads/jsevaluator/interfaces/HandlerWrapperInterface.java

@@ -0,0 +1,6 @@
+package csdk.gluads.jsevaluator.interfaces;
+
+/* loaded from: classes4.dex */
+public interface HandlerWrapperInterface {
+    void post(Runnable runnable);
+}

decompiled/sources/csdk/gluads/jsevaluator/interfaces/JsCallback.java

@@ -0,0 +1,8 @@
+package csdk.gluads.jsevaluator.interfaces;
+
+/* loaded from: classes4.dex */
+public interface JsCallback {
+    void onError(String str);
+
+    void onResult(String str);
+}

decompiled/sources/csdk/gluads/jsevaluator/interfaces/JsEvaluatorInterface.java

@@ -0,0 +1,16 @@
+package csdk.gluads.jsevaluator.interfaces;
+
+import android.webkit.WebView;
+
+/* loaded from: classes4.dex */
+public interface JsEvaluatorInterface {
+    void callFunction(String str, JsCallback jsCallback, String str2, Object... objArr);
+
+    void destroy();
+
+    void evaluate(String str);
+
+    void evaluate(String str, JsCallback jsCallback);
+
+    WebView getWebView();
+}

decompiled/sources/csdk/gluads/jsevaluator/interfaces/WebViewWrapperInterface.java

@@ -0,0 +1,12 @@
+package csdk.gluads.jsevaluator.interfaces;
+
+import android.webkit.WebView;
+
+/* loaded from: classes4.dex */
+public interface WebViewWrapperInterface {
+    void destroy();
+
+    WebView getWebView();
+
+    void loadJavaScript(String str);
+}

decompiled/sources/csdk/gluads/max/EAMax.java

@@ -0,0 +1,237 @@
+package csdk.gluads.max;
+
+import android.app.Activity;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.applovin.mediation.adapter.MaxAdapter;
+import com.applovin.mediation.adapter.listeners.MaxInterstitialAdapterListener;
+import com.applovin.mediation.adapter.listeners.MaxRewardedAdapterListener;
+import com.applovin.mediation.adapter.listeners.MaxRewardedInterstitialAdapterListener;
+import com.applovin.mediation.adapter.listeners.MaxSignalCollectionListener;
+import com.applovin.sdk.AppLovinPrivacySettings;
+import com.applovin.sdk.AppLovinSdk;
+import com.applovin.sdk.AppLovinSdkConfiguration;
+import com.applovin.sdk.AppLovinSdkSettings;
+import com.facebook.ads.AdSettings;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import csdk.gluads.Consts;
+import csdk.gluads.CustomSettings;
+import csdk.gluads.GluAdsFactory;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.eventbus.GluEventBus;
+import csdk.gluads.impl.AdvertisingImpl;
+import csdk.gluads.impl.DummyAdvertising;
+import csdk.gluads.util.AdvertisingUtil;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.Futures;
+import csdk.gluads.util.IAction1;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import csdk.gluads.util.log.YLoggers;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+
+/* loaded from: classes4.dex */
+public class EAMax {
+    private static final YLogger log = YLoggerFactory.getLogger((Class<?>) EAMax.class);
+    private static Map<String, String> mAdapterNames;
+    private static Set<String> mDisabledAdapters;
+    private static AppLovinSdk mSdk;
+
+    static {
+        HashMap hashMap = new HashMap();
+        mAdapterNames = hashMap;
+        hashMap.put(Consts.SDK_FACEBOOK_AUDIENCE_NETWORK, "com.applovin.mediation.adapters.FacebookMediationAdapter");
+        mAdapterNames.put("fyber", "com.applovin.mediation.adapters.InneractiveMediationAdapter");
+        mAdapterNames.put(Consts.SDK_ADMOB, "com.applovin.mediation.adapters.GoogleMediationAdapter");
+        mAdapterNames.put("gam", "com.applovin.mediation.adapters.GoogleAdManagerMediationAdapter");
+        mAdapterNames.put(Consts.SDK_IRONSOURCE, "com.applovin.mediation.adapters.IronSourceMediationAdapter");
+        mAdapterNames.put(Consts.SDK_MINTEGRAL, "com.applovin.mediation.adapters.MintegralMediationAdapter");
+        mAdapterNames.put(Consts.SDK_TAPJOY, "com.applovin.mediation.adapters.TapjoyMediationAdapter");
+        mAdapterNames.put(Consts.SDK_UNITY_ADS, "com.applovin.mediation.adapters.UnityAdsMediationAdapter");
+        mAdapterNames.put(Consts.SDK_VUNGLE, "com.applovin.mediation.adapters.VungleMediationAdapter");
+    }
+
+    public static boolean isAdapterDisabled(String str) {
+        return mDisabledAdapters.contains(str);
+    }
+
+    public static boolean adapterDisabled(String str, MaxAdapter.OnCompletionListener onCompletionListener) {
+        if (!isAdapterDisabled(str)) {
+            return false;
+        }
+        if (onCompletionListener == null) {
+            return true;
+        }
+        onCompletionListener.onCompletion(MaxAdapter.InitializationStatus.INITIALIZED_FAILURE, null);
+        return true;
+    }
+
+    public static boolean adapterDisabled(String str, MaxInterstitialAdapterListener maxInterstitialAdapterListener) {
+        if (!isAdapterDisabled(str)) {
+            return false;
+        }
+        if (maxInterstitialAdapterListener == null) {
+            return true;
+        }
+        maxInterstitialAdapterListener.onInterstitialAdLoadFailed(null);
+        return true;
+    }
+
+    public static boolean adapterDisabled(String str, MaxRewardedInterstitialAdapterListener maxRewardedInterstitialAdapterListener) {
+        if (!isAdapterDisabled(str)) {
+            return false;
+        }
+        if (maxRewardedInterstitialAdapterListener == null) {
+            return true;
+        }
+        maxRewardedInterstitialAdapterListener.onRewardedInterstitialAdLoadFailed(null);
+        return true;
+    }
+
+    public static boolean adapterDisabled(String str, MaxRewardedAdapterListener maxRewardedAdapterListener) {
+        if (!isAdapterDisabled(str)) {
+            return false;
+        }
+        if (maxRewardedAdapterListener == null) {
+            return true;
+        }
+        maxRewardedAdapterListener.onRewardedAdLoadFailed(null);
+        return true;
+    }
+
+    public static boolean adapterDisabled(String str, MaxSignalCollectionListener maxSignalCollectionListener) {
+        if (!isAdapterDisabled(str)) {
+            return false;
+        }
+        if (maxSignalCollectionListener == null) {
+            return true;
+        }
+        maxSignalCollectionListener.onSignalCollectionFailed(str + " is disabled");
+        return true;
+    }
+
+    public static Future<?> createMAX(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @NonNull CustomSettings customSettings, boolean z, PrivacyStatus privacyStatus, @NonNull final AdvertisingImpl advertisingImpl) {
+        mDisabledAdapters = new HashSet();
+        Map<String, Object> configDisabled = GluAdsFactory.configDisabled(map);
+        final Activity activity = (Activity) Common.call(callable);
+        IAction1<PrivacyStatus> iAction1 = new IAction1<PrivacyStatus>() { // from class: csdk.gluads.max.EAMax.1
+            @Override // csdk.gluads.util.IAction1
+            public void apply(PrivacyStatus privacyStatus2) {
+            }
+        };
+        for (String str : Consts.SDK_ARRAY_AD_NETWORKS) {
+            if (ConfigUtil.getBoolean(configDisabled, str)) {
+                mDisabledAdapters.add(getAdapterClassName(str));
+            }
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, str, Consts.SDK_PRIVACY_STAGE_ADDED, iAction1, advertisingImpl);
+        }
+        if (ConfigUtil.getBoolean(configDisabled, "gam")) {
+            mDisabledAdapters.add(getAdapterClassName("gam"));
+        }
+        final String string = ConfigUtil.getString(ConfigUtil.configSdk(map), "appLovin.sdkKey");
+        if (TextUtils.isEmpty(string)) {
+            YLoggers.sdkConfiguration(log, Consts.SDK_APPLOVIN, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE, Consts.KEY_TAPJOY_USER_ID_VERSION, "AppLovin SDK key is null or empty");
+            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_APPLOVIN, "disabled", null, advertisingImpl);
+            return GluAdsFactory.disabledFuture();
+        }
+        final AppLovinSdkSettings appLovinSdkSettings = new AppLovinSdkSettings(activity);
+        appLovinSdkSettings.setVerboseLogging(z);
+        if (!z) {
+            appLovinSdkSettings.setCreativeDebuggerEnabled(false);
+        }
+        if (ConfigUtil.getBoolean(ConfigUtil.configSdk(map), "debug.maxTestMode")) {
+            String gaid = Common.getGAID(activity);
+            if (!TextUtils.isEmpty(gaid)) {
+                appLovinSdkSettings.setTestDeviceAdvertisingIds(Arrays.asList(gaid));
+            }
+        }
+        AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_APPLOVIN, Consts.SDK_PRIVACY_STAGE_ADDED, new IAction1<PrivacyStatus>() { // from class: csdk.gluads.max.EAMax.2
+            @Override // csdk.gluads.util.IAction1
+            public void apply(PrivacyStatus privacyStatus2) {
+                if (privacyStatus2.gdprApplies) {
+                    AppLovinSdkSettings.this.setExtraParameter("consent_dialog_state", "applies");
+                    AppLovinSdkSettings.this.setExtraParameter("huc", Boolean.toString(privacyStatus2.hasConsent));
+                    AppLovinPrivacySettings.setHasUserConsent(privacyStatus2.hasConsent, activity);
+                }
+                if (privacyStatus2.ccpaApplies) {
+                    AppLovinSdkSettings.this.setExtraParameter("dns", Boolean.toString(privacyStatus2.ccpaOptOut));
+                    AppLovinPrivacySettings.setDoNotSell(privacyStatus2.ccpaOptOut, activity);
+                }
+                if (privacyStatus2.ccpaOptOut) {
+                    AdSettings.setDataProcessingOptions(new String[]{"LDU"}, 0, 0);
+                } else {
+                    AdSettings.setDataProcessingOptions(new String[0]);
+                }
+                if (AppLovinPrivacySettings.getAdditionalConsentStatus(89) != null) {
+                    AdSettings.setDataProcessingOptions(new String[]{"LDU"}, 0, 0);
+                }
+                AppLovinSdk appLovinSdk = AppLovinSdk.getInstance(string, AppLovinSdkSettings.this, activity);
+                if (appLovinSdk == null) {
+                    EAMax.log.e("max", "Cannot acces AppLovinSdk instance");
+                    AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_APPLOVIN, "disabled", null, advertisingImpl);
+                    return;
+                }
+                Map<String, IAdvertising> componentHandlers = advertisingImpl.getComponentHandlers();
+                boolean z2 = true;
+                for (Map.Entry<String, IAdvertising> entry : componentHandlers.entrySet()) {
+                    IAdvertising value = entry.getValue();
+                    if (value != null) {
+                        try {
+                            componentHandlers.put(entry.getKey(), ((EAMaxManagerProxy) value).createManager(appLovinSdk));
+                            z2 = false;
+                        } catch (ClassCastException unused) {
+                        }
+                    }
+                }
+                if (z2) {
+                    return;
+                }
+                appLovinSdk.setMediationProvider("max");
+                AppLovinSdk unused2 = EAMax.mSdk = appLovinSdk;
+                EAMax.log.d("SDK.VERSION", Consts.SDK_APPLOVIN, AppLovinSdk.VERSION, InneractiveMediationDefs.GENDER_MALE, "sdkInitialize begin");
+                EAMax.mSdk.initializeSdk(new AppLovinSdk.SdkInitializationListener() { // from class: csdk.gluads.max.EAMax.2.1
+                    @Override // com.applovin.sdk.AppLovinSdk.SdkInitializationListener
+                    public void onSdkInitialized(AppLovinSdkConfiguration appLovinSdkConfiguration) {
+                        EAMax.log.d("SDK.VERSION", Consts.SDK_APPLOVIN, AppLovinSdk.VERSION, InneractiveMediationDefs.GENDER_MALE, "onSdkInitialized");
+                    }
+                });
+            }
+        }, advertisingImpl);
+        YLoggers.sdkConfiguration(log, Consts.SDK_APPLOVIN, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.TRUE);
+        return Futures.successful("max");
+    }
+
+    @NonNull
+    public static IAdvertising createRVManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, boolean z, GluEventBus gluEventBus) {
+        Map<String, Object> configDisabled = ConfigUtil.configDisabled(map);
+        if (ConfigUtil.getBoolean(configDisabled, "max")) {
+            YLoggers.sdkConfiguration(log, "max", "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
+            return new DummyAdvertising();
+        }
+        Map<String, Object> configSdk = ConfigUtil.configSdk(map);
+        return new EAMaxManagerProxy(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, callable, Common.mapSSFromConfig(ConfigUtil.getConfigMapVariant(configSdk, "max.rewardedInterstitialPlacementMapping", z, null)), ConfigUtil.getMap(configSdk, "frequency", null), ConfigUtil.getString(configSdk, "max.placementRewardSeparator", ","), ConfigUtil.getMap(configSdk, "max.rewards"), ConfigUtil.shouldSendImpressionData(configDisabled), ConfigUtil.getBoolean(configDisabled, Consts.IS_LOADED_IGNORE_FREQUENCYCAPPING, false), ConfigUtil.getBoolean(configDisabled, Consts.GLOBAL_FREQUENCY_CAPPING, false), ConfigUtil.getBoolean(configSdk, "debug.all", false), gluEventBus);
+    }
+
+    @NonNull
+    public static IAdvertising createInterstitialManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, boolean z, GluEventBus gluEventBus) {
+        Map<String, Object> configDisabled = ConfigUtil.configDisabled(map);
+        if (ConfigUtil.getBoolean(configDisabled, "max")) {
+            YLoggers.sdkConfiguration(log, "max", "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
+            return new DummyAdvertising();
+        }
+        Map<String, Object> configSdk = ConfigUtil.configSdk(map);
+        return new EAMaxManagerProxy("interstitial", callable, Common.mapSSFromConfig(ConfigUtil.getConfigMapVariant(configSdk, "max.interstitialPlacementMapping", z, null)), ConfigUtil.getMap(configSdk, "frequency", null), ConfigUtil.shouldSendImpressionData(configDisabled), ConfigUtil.getBoolean(configDisabled, Consts.IS_LOADED_IGNORE_FREQUENCYCAPPING, false), ConfigUtil.getBoolean(configSdk, "debug.all", false), gluEventBus);
+    }
+
+    private static String getAdapterClassName(String str) {
+        return mAdapterNames.get(str);
+    }
+}

decompiled/sources/csdk/gluads/max/EAMaxInterstitialManager.java

@@ -0,0 +1,183 @@
+package csdk.gluads.max;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.applovin.mediation.MaxAd;
+import com.applovin.mediation.MaxAdListener;
+import com.applovin.mediation.MaxError;
+import com.applovin.mediation.ads.MaxInterstitialAd;
+import com.applovin.sdk.AppLovinSdk;
+import com.applovin.sdk.AppLovinSdkSettings;
+import csdk.gluads.Consts;
+import csdk.gluads.max.EAMaxManagerBase;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes4.dex */
+public class EAMaxInterstitialManager extends EAMaxManagerBase {
+    private final Map<String, MaxInterstitialAd> mAds;
+    private boolean mIsLoadedIgnoreFrequencyCapping;
+    private boolean mSendImpressionData;
+
+    @Override // csdk.gluads.max.EAMaxManagerBase
+    public String adType() {
+        return "interstitial";
+    }
+
+    public class EAMaxInterstitialListener extends EAMaxManagerBase.EAMaxListener implements MaxAdListener {
+        public EAMaxInterstitialListener() {
+            super();
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdLoaded(MaxAd maxAd) {
+            sendLoadPlacementEvent(Consts.PLACEMENT_STATUS_LOAD_FINISHED, null);
+            clearLoadingPlacements();
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdDisplayed(MaxAd maxAd) {
+            EAMaxInterstitialManager.this.getCrossPromos().remove(maxAd.getPlacement());
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdHidden(MaxAd maxAd) {
+            EAMaxInterstitialManager.this.frequencyController().increaseCount(EAMaxInterstitialManager.this.isCrossPromo(maxAd.getAdUnitId()), showingPlacement());
+            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, null);
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdClicked(MaxAd maxAd) {
+            Map<String, Object> createMap = Common.createMap();
+            createMap.putAll(this.mExtra);
+            if (EAMaxInterstitialManager.this.isCrossPromo(maxAd.getAdUnitId())) {
+                createMap.put(Consts.IS_CROSS_PROMO, 1);
+                Map<String, Object> map = ConfigUtil.getMap(EAMaxInterstitialManager.this.getImpressionMapping(), maxAd.getAdUnitId());
+                if (map != null) {
+                    createMap.putAll(map);
+                }
+            }
+            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_CLICKED, null, createMap);
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdLoadFailed(String str, MaxError maxError) {
+            sendLoadPlacementEvent(Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalStateException("Failed to load ad: " + maxError.toString()));
+            clearLoadingPlacements();
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdDisplayFailed(MaxAd maxAd, MaxError maxError) {
+            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, new IllegalStateException("Failed to show ad: " + String.format("{code:%s, msg:%s, waterfall:%s}", Integer.valueOf(maxError.getCode()), maxError.getMessage(), maxError.getWaterfall())));
+        }
+    }
+
+    public EAMaxInterstitialManager(@NonNull AppLovinSdk appLovinSdk, EAMaxManagerBase eAMaxManagerBase, boolean z, boolean z2) {
+        super(appLovinSdk, eAMaxManagerBase);
+        this.mAds = new ConcurrentHashMap();
+        this.mSendImpressionData = z;
+        this.mIsLoadedIgnoreFrequencyCapping = z2;
+    }
+
+    public MaxInterstitialAd getAdForAdUnitID(String str) {
+        if (str == null) {
+            return null;
+        }
+        return this.mAds.get(str);
+    }
+
+    public void setAdForAdUnitID(String str, MaxInterstitialAd maxInterstitialAd) {
+        EAMaxInterstitialListener eAMaxInterstitialListener = new EAMaxInterstitialListener();
+        maxInterstitialAd.setListener(eAMaxInterstitialListener);
+        addListenerForAdUnitId(eAMaxInterstitialListener, str);
+        synchronized (this.mAds) {
+            this.mAds.put(str, maxInterstitialAd);
+        }
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        MaxInterstitialAd adForAdUnitID = getAdForAdUnitID(getAdUnitId(str2, false));
+        if (adForAdUnitID == null || !adForAdUnitID.isReady()) {
+            return false;
+        }
+        return this.mIsLoadedIgnoreFrequencyCapping || !isCapped(str2);
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        if (TextUtils.equals(str2, Consts.DEBUG_PLACEMENT)) {
+            getSdk().showMediationDebugger();
+            return;
+        }
+        String adUnitId = getAdUnitId(str2);
+        if (TextUtils.isEmpty(adUnitId)) {
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalArgumentException("No mapping for " + str2 + Consts.STRING_PERIOD), map);
+            return;
+        }
+        if (crossPromoMappingContains(adUnitId).booleanValue()) {
+            loadAdOnCrossPromoTargetAppCheck(str2, ConfigUtil.getString(ConfigUtil.getMap(getImpressionMapping(), adUnitId), "campaign_name"), map);
+        } else {
+            directLoad(str2, map);
+        }
+    }
+
+    @Override // csdk.gluads.eventbus.GluAdsManagerEventHandler
+    public void directLoad(String str, @NonNull Map<String, Object> map) {
+        if (TextUtils.equals(str, Consts.DEBUG_PLACEMENT)) {
+            getSdk().showMediationDebugger();
+            return;
+        }
+        String adUnitId = getAdUnitId(str);
+        MaxInterstitialAd adForAdUnitID = getAdForAdUnitID(adUnitId);
+        if (adForAdUnitID == null) {
+            adForAdUnitID = new MaxInterstitialAd(adUnitId, getSdk(), getActivity());
+            setAdForAdUnitID(adUnitId, adForAdUnitID);
+        } else if (adForAdUnitID.isReady()) {
+            sendPlacementEvent(str, Consts.PLACEMENT_STATUS_LOAD_FINISHED, null, map);
+            return;
+        }
+        if (crossPromoMappingContains(adUnitId).booleanValue()) {
+            setCrossPromoLoaded(adUnitId);
+        }
+        EAMaxManagerBase.EAMaxListener listenerForAdUnitId = getListenerForAdUnitId(adUnitId);
+        if (listenerForAdUnitId != null) {
+            listenerForAdUnitId.addLoadingPlacement(str);
+        }
+        AppLovinSdkSettings settings = getSdk().getSettings();
+        String string = ConfigUtil.getString(map, Consts.MAX_TEST_MODE_NETWORK);
+        if (string != null) {
+            settings.setExtraParameter(Consts.MAX_TEST_MODE_NETWORK, string);
+        } else if (isTestPlacement(str)) {
+            settings.setExtraParameter(Consts.MAX_TEST_MODE_NETWORK, getTestNetwork(str));
+        }
+        adForAdUnitID.loadAd();
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        if (TextUtils.equals(str2, Consts.DEBUG_PLACEMENT)) {
+            getSdk().showMediationDebugger();
+            return;
+        }
+        if (isLoaded(str, str2, map)) {
+            String adUnitId = getAdUnitId(str2);
+            MaxInterstitialAd adForAdUnitID = getAdForAdUnitID(adUnitId);
+            ((EAMaxManagerBase) this).mLog.d("INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "l", "max");
+            EAMaxManagerBase.EAMaxListener listenerForAdUnitId = getListenerForAdUnitId(adUnitId);
+            if (listenerForAdUnitId != null) {
+                listenerForAdUnitId.setShowingPlacement(str2);
+            }
+            if (isCrossPromo(adUnitId)) {
+                ((EAMaxManagerBase) this).mLog.d("INTERSTITIAL.LOAD", Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "placement", adUnitId, "adUnitID", "max");
+            }
+            adForAdUnitID.setRevenueListener(makeRevenueListener(str2, map, this.mSendImpressionData));
+            adForAdUnitID.showAd(str2);
+            return;
+        }
+        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Not ready"), map);
+    }
+}

decompiled/sources/csdk/gluads/max/EAMaxManagerBase.java

@@ -0,0 +1,448 @@
+package csdk.gluads.max;
+
+import android.app.Activity;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.webkit.ProxyConfig;
+import com.applovin.mediation.MaxAd;
+import com.applovin.mediation.MaxAdRevenueListener;
+import com.applovin.sdk.AppLovinSdk;
+import com.ironsource.nb;
+import com.tapjoy.TapjoyConstants;
+import csdk.gluads.Consts;
+import csdk.gluads.FrequencyController;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import csdk.gluads.eventbus.GluAdsManagerEventHandler;
+import csdk.gluads.impl.NullAdvertisingListener;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class EAMaxManagerBase extends GluAdsManagerEventHandler implements IAdvertising {
+    static final String CROSSPROMO_PROVIDER = "APPLOVIN_DIRECTSOLD";
+    private final Activity mActivity;
+    private final Map<String, EAMaxListener> mAdUnitIdToListener;
+    private Set<String> mCrossPromoLoaded;
+    private final Map<String, String> mCrossPromotions;
+    private final AtomicReference<String> mDefaultAddUnitId;
+    private final AtomicReference<FrequencyController> mFrequencyController;
+    private Map<String, Object> mImpressionMapping;
+    protected boolean mIsDebug;
+    private final AtomicReference<IAdvertisingListener> mListener;
+    protected final YLogger mLog;
+    private final Map<String, String> mPlacementToAdUnitId;
+    private AppLovinSdk mSdk;
+    final Set<String> testPlacementNames;
+
+    public String adType() {
+        return null;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    public Activity getActivity() {
+        return this.mActivity;
+    }
+
+    @NonNull
+    public Map<String, String> getCrossPromos() {
+        return this.mCrossPromotions;
+    }
+
+    @NonNull
+    public Map<String, Object> getImpressionMapping() {
+        return this.mImpressionMapping;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return null;
+    }
+
+    @NonNull
+    public AppLovinSdk getSdk() {
+        return this.mSdk;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+    }
+
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return false;
+    }
+
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+    }
+
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    public class EAMaxListener extends EAPlacementListener {
+        final Map<String, Object> mExtra;
+        private final List<String> mLoadingPlacements;
+
+        public EAMaxListener() {
+            Map<String, Object> createMap = Common.createMap();
+            this.mExtra = createMap;
+            createMap.put(Consts.MEDIATION_NETWORK, "max");
+            this.mLoadingPlacements = new ArrayList();
+        }
+
+        public void addLoadingPlacement(String str) {
+            synchronized (this.mLoadingPlacements) {
+                try {
+                    if (!this.mLoadingPlacements.contains(str)) {
+                        this.mLoadingPlacements.add(str);
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+
+        public void clearLoadingPlacements() {
+            synchronized (this.mLoadingPlacements) {
+                this.mLoadingPlacements.clear();
+            }
+        }
+
+        public void sendLoadPlacementEvent(String str, Throwable th) {
+            sendLoadPlacementEvent(str, th, null);
+        }
+
+        public void sendLoadPlacementEvent(String str, Throwable th, Map<String, Object> map) {
+            synchronized (this.mLoadingPlacements) {
+                try {
+                    Iterator<String> it = this.mLoadingPlacements.iterator();
+                    while (it.hasNext()) {
+                        sendSinglePlacementEvent(it.next(), str, th, map);
+                    }
+                } catch (Throwable th2) {
+                    throw th2;
+                }
+            }
+        }
+
+        public void sendSinglePlacementEvent(String str, String str2, Throwable th) {
+            sendSinglePlacementEvent(str, str2, th, this.mExtra);
+        }
+
+        public void sendSinglePlacementEvent(String str, String str2, Throwable th, Map<String, Object> map) {
+            EAMaxManagerBase.this.sendPlacementEvent(str, str2, th, map);
+        }
+    }
+
+    public EAMaxManagerBase(String str, Callable<Activity> callable, Map<String, String> map, Map<String, Object> map2, boolean z) {
+        super(str);
+        this.testPlacementNames = new HashSet(Arrays.asList("admob", "applovin", "fyber", "facebook", "fan", "googleadmanager", "gam", "ironsource", Consts.SDK_MINTEGRAL, Consts.SDK_TAPJOY, TapjoyConstants.TJC_PLUGIN_UNITY, Consts.SDK_VUNGLE));
+        this.mLog = YLoggerFactory.getLogger(getClass());
+        this.mIsDebug = false;
+        Activity activity = (Activity) Common.call(callable);
+        this.mActivity = activity;
+        this.mListener = new AtomicReference<>(NullAdvertisingListener.INSTANCE);
+        this.mFrequencyController = new AtomicReference<>(new FrequencyController(str, activity.getApplicationContext(), map2));
+        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
+        this.mPlacementToAdUnitId = concurrentHashMap;
+        this.mAdUnitIdToListener = new ConcurrentHashMap();
+        AtomicReference<String> atomicReference = new AtomicReference<>();
+        this.mDefaultAddUnitId = atomicReference;
+        this.mIsDebug = z;
+        if (map != null) {
+            String remove = map.remove(ProxyConfig.MATCH_ALL_SCHEMES);
+            if (!TextUtils.isEmpty(remove)) {
+                atomicReference.set(remove);
+            }
+            synchronized (concurrentHashMap) {
+                concurrentHashMap.putAll(map);
+            }
+        }
+        this.mImpressionMapping = new ConcurrentHashMap();
+        this.mCrossPromotions = Collections.synchronizedMap(Common.createMap());
+        this.mCrossPromoLoaded = Collections.newSetFromMap(new ConcurrentHashMap());
+    }
+
+    public EAMaxManagerBase(EAMaxManagerBase eAMaxManagerBase) {
+        super(eAMaxManagerBase.adType());
+        this.testPlacementNames = new HashSet(Arrays.asList("admob", "applovin", "fyber", "facebook", "fan", "googleadmanager", "gam", "ironsource", Consts.SDK_MINTEGRAL, Consts.SDK_TAPJOY, TapjoyConstants.TJC_PLUGIN_UNITY, Consts.SDK_VUNGLE));
+        this.mLog = YLoggerFactory.getLogger(getClass());
+        this.mIsDebug = false;
+        this.mActivity = eAMaxManagerBase.mActivity;
+        this.mListener = eAMaxManagerBase.mListener;
+        this.mFrequencyController = eAMaxManagerBase.mFrequencyController;
+        this.mPlacementToAdUnitId = eAMaxManagerBase.mPlacementToAdUnitId;
+        this.mAdUnitIdToListener = eAMaxManagerBase.mAdUnitIdToListener;
+        this.mDefaultAddUnitId = eAMaxManagerBase.mDefaultAddUnitId;
+        this.mImpressionMapping = eAMaxManagerBase.mImpressionMapping;
+        this.mCrossPromotions = eAMaxManagerBase.mCrossPromotions;
+        this.mCrossPromoLoaded = eAMaxManagerBase.mCrossPromoLoaded;
+    }
+
+    public EAMaxManagerBase(@NonNull AppLovinSdk appLovinSdk, EAMaxManagerBase eAMaxManagerBase) {
+        this(eAMaxManagerBase);
+        this.mSdk = appLovinSdk;
+    }
+
+    public boolean isCapped(@NonNull String str) {
+        return frequencyController().isLimitReached(str);
+    }
+
+    public void addListenerForAdUnitId(EAMaxListener eAMaxListener, String str) {
+        synchronized (this.mAdUnitIdToListener) {
+            this.mAdUnitIdToListener.put(str, eAMaxListener);
+        }
+    }
+
+    public EAMaxListener getListenerForAdUnitId(String str) {
+        EAMaxListener eAMaxListener;
+        synchronized (this.mAdUnitIdToListener) {
+            eAMaxListener = this.mAdUnitIdToListener.get(str);
+        }
+        return eAMaxListener;
+    }
+
+    public Boolean crossPromoMappingContains(String str) {
+        return Boolean.valueOf(this.mCrossPromotions.values().contains(str));
+    }
+
+    public IAdvertisingListener listener() {
+        return this.mListener.get();
+    }
+
+    public FrequencyController frequencyController() {
+        return this.mFrequencyController.get();
+    }
+
+    public void setCrossPromoLoaded(String str) {
+        this.mCrossPromoLoaded.add(str);
+    }
+
+    public boolean isCrossPromo(String str) {
+        return this.mCrossPromoLoaded.contains(str);
+    }
+
+    public String getAdUnitId(String str, boolean z) {
+        if (getCrossPromos().containsKey(str) && (!z || !isCrossPromoBlocked(str))) {
+            String str2 = getCrossPromos().get(str);
+            if (frequencyController().shouldShowCrossPromo(str) && !str2.isEmpty()) {
+                return str2;
+            }
+        }
+        String str3 = this.mPlacementToAdUnitId.get(str);
+        return TextUtils.isEmpty(str3) ? this.mDefaultAddUnitId.get() : str3;
+    }
+
+    public String getAdUnitId(String str) {
+        return getAdUnitId(str, true);
+    }
+
+    public MaxAdRevenueListener makeRevenueListener(final String str, @Nullable final Map<String, Object> map, final boolean z) {
+        return new MaxAdRevenueListener() { // from class: csdk.gluads.max.EAMaxManagerBase.1
+            @Override // com.applovin.mediation.MaxAdRevenueListener
+            public void onAdRevenuePaid(MaxAd maxAd) {
+                sendImpressionInternal(str, map, maxAd);
+                sendImpressionSingular(str, maxAd);
+            }
+
+            private void sendImpressionInternal(String str2, @Nullable Map<String, Object> map2, MaxAd maxAd) {
+                Map<String, Object> createMap = Common.createMap();
+                if (map2 != null) {
+                    createMap.putAll(map2);
+                }
+                if (z) {
+                    createMap.put(Consts.SERVED_BY_NETWORK, maxAd.getNetworkName());
+                    createMap.put(Consts.KEY_NAME_PUB_REVENUE, Double.valueOf(maxAd.getRevenue()));
+                    createMap.put("precision", maxAd.getRevenuePrecision());
+                    createMap.put("max_show_placement", maxAd.getPlacement());
+                    if (!TextUtils.isEmpty(maxAd.getCreativeId())) {
+                        createMap.put(Consts.CREATIVE_ID, maxAd.getCreativeId());
+                    }
+                    if (!TextUtils.isEmpty(maxAd.getAdUnitId())) {
+                        createMap.put("adUnit", maxAd.getAdUnitId());
+                    }
+                    if (EAMaxManagerBase.this.isCrossPromo(maxAd.getAdUnitId())) {
+                        if (!TextUtils.equals(maxAd.getNetworkName(), EAMaxManagerBase.CROSSPROMO_PROVIDER)) {
+                            EAMaxManagerBase.this.mLog.d("Failed to load a cross promo, marking as regular ad", maxAd.getAdUnitId(), str2, "l", "max");
+                            EAMaxManagerBase.this.mCrossPromoLoaded.remove(maxAd.getAdUnitId());
+                        } else {
+                            createMap.put(Consts.IS_CROSS_PROMO, 1);
+                            Map<String, Object> map3 = ConfigUtil.getMap(EAMaxManagerBase.this.getImpressionMapping(), maxAd.getAdUnitId());
+                            if (map3 != null) {
+                                createMap.putAll(map3);
+                            }
+                        }
+                    }
+                }
+                EAMaxManagerBase.this.sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, null, createMap);
+            }
+
+            private void sendImpressionSingular(String str2, MaxAd maxAd) {
+                if (z) {
+                    Map<String, Object> createMap = Common.createMap();
+                    createMap.put("ad_platform", "AppLovin");
+                    createMap.put("ad_currency", "USD");
+                    createMap.put("ad_revenue", Double.valueOf(maxAd.getRevenue()));
+                    createMap.put("withAdUnitId", maxAd.getAdUnitId());
+                    createMap.put("withNetworkName", maxAd.getNetworkName());
+                    createMap.put("withAdType", maxAd.getFormat().getLabel());
+                    EAMaxManagerBase.this.sendPlacementEvent(str2, Consts.SINGULAR_AD_REVENUE_REPORT, null, createMap);
+                }
+            }
+        };
+    }
+
+    public void sendPlacementEvent(String str, String str2, Throwable th, Map<String, Object> map) {
+        if (th == null && str2 == Consts.PLACEMENT_STATUS_LOAD_FINISHED && isCapped(str)) {
+            th = new IllegalArgumentException("FrequencyCap limit.");
+            if (frequencyController().isFreqCountRefreshRequired(str)) {
+                if (map == null) {
+                    map = Common.createMap();
+                }
+                map.put(Consts.KEY_NAME_FREQUENCY_REFRESH, new Boolean(true));
+            }
+        }
+        internal_sendPlacementEvent(str, str2, th, map);
+    }
+
+    public void internal_sendPlacementEvent(String str, String str2, Throwable th, Map<String, Object> map) {
+        if (th != null) {
+            this.mLog.e(adType() + Consts.STRING_PERIOD + str2, nb.q, str, "l", "max", "error", th);
+        } else {
+            this.mLog.d(adType() + Consts.STRING_PERIOD + str2, nb.q, str, "l", "max", "extra", map);
+        }
+        if (map == null) {
+            map = Common.createMap();
+        }
+        Map<String, Object> map2 = map;
+        map2.put("network", "max");
+        listener().onPlacementEvent(new PlacementEvent(adType(), str, str2, th, map2));
+    }
+
+    public boolean isTestPlacement(String str) {
+        return this.testPlacementNames.contains(str.toLowerCase(Locale.US));
+    }
+
+    public String getTestNetwork(String str) {
+        String lowerCase = str.toLowerCase(Locale.US);
+        lowerCase.hashCode();
+        switch (lowerCase) {
+            case "googleadmanager":
+            case "gam":
+                return "GOOGLE_AD_MANAGER_NETWORK";
+            case "ironsource":
+                return "IRONSOURCE_NETWORK";
+            case "tapjoy":
+                return "TAPJOY_NETWORK";
+            case "vungle":
+                return "VUNGLE_NETWORK";
+            case "fan":
+            case "facebook":
+                return "FACEBOOK_NETWORK";
+            case "admob":
+                return "ADMOB_NETWORK";
+            case "fyber":
+                return "FYBER_NETWORK";
+            case "unity":
+                return "UNITY_NETWORK";
+            case "mintegral":
+                return "MINTEGRAL_BIDDING";
+            default:
+                return "APPLOVIN_NETWORK";
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
+        AtomicReference<IAdvertisingListener> atomicReference = this.mListener;
+        if (iAdvertisingListener == null) {
+            iAdvertisingListener = NullAdvertisingListener.INSTANCE;
+        }
+        atomicReference.set(iAdvertisingListener);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
+        frequencyController().update(map);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+        synchronized (this.mCrossPromotions) {
+            this.mCrossPromotions.clear();
+            this.mCrossPromotions.putAll(Common.mapSSFromConfig(map));
+        }
+        synchronized (this.mImpressionMapping) {
+            try {
+                this.mImpressionMapping.clear();
+                Map<String, Object> map3 = this.mImpressionMapping;
+                if (map3 != null) {
+                    map3.putAll(map2);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+        frequencyController().onNewSession();
+    }
+}

decompiled/sources/csdk/gluads/max/EAMaxManagerProxy.java

@@ -0,0 +1,167 @@
+package csdk.gluads.max;
+
+import android.app.Activity;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.applovin.sdk.AppLovinSdk;
+import csdk.gluads.Consts;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import csdk.gluads.eventbus.GluEventBus;
+import csdk.gluads.impl.DummyAdvertising;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class EAMaxManagerProxy extends EAMaxManagerBase {
+    private final String mAdType;
+    private GluEventBus mEventBus;
+    private AtomicReference<String> mGemsData;
+    private boolean mIsDebug;
+    private boolean mIsLoadedIgnoreFrequencyCapping;
+    private final Map<String, Object> mRewards;
+    private final String mSeparator;
+    private boolean mShouldIgnoreGlobalFrequencyCapping;
+    private final boolean mShouldSendImpressionData;
+    private AtomicReference<String> mUserId;
+
+    @Override // csdk.gluads.max.EAMaxManagerBase
+    public String adType() {
+        return this.mAdType;
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void destroy() {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return null;
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return false;
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void onPause() {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void onResume() {
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+    }
+
+    public EAMaxManagerProxy(String str, Callable<Activity> callable, Map<String, String> map, Map<String, Object> map2, String str2, Map<String, Object> map3, boolean z, boolean z2, boolean z3, boolean z4, GluEventBus gluEventBus) {
+        super(str, callable, map, map2, z4);
+        this.mAdType = str;
+        this.mSeparator = str2;
+        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
+        this.mRewards = concurrentHashMap;
+        if (map3 != null) {
+            synchronized (concurrentHashMap) {
+                concurrentHashMap.putAll(map3);
+            }
+        }
+        this.mUserId = new AtomicReference<>();
+        this.mGemsData = new AtomicReference<>();
+        this.mShouldSendImpressionData = z;
+        this.mShouldIgnoreGlobalFrequencyCapping = z3;
+        this.mEventBus = gluEventBus;
+    }
+
+    public EAMaxManagerProxy(String str, Callable<Activity> callable, Map<String, String> map, Map<String, Object> map2, boolean z, boolean z2, boolean z3, GluEventBus gluEventBus) {
+        super(str, callable, map, map2, z3);
+        this.mAdType = str;
+        this.mSeparator = null;
+        this.mRewards = null;
+        this.mUserId = new AtomicReference<>();
+        this.mGemsData = new AtomicReference<>();
+        this.mShouldSendImpressionData = z;
+        this.mIsLoadedIgnoreFrequencyCapping = z2;
+        this.mEventBus = gluEventBus;
+    }
+
+    public IAdvertising createManager(AppLovinSdk appLovinSdk) {
+        String adType = adType();
+        adType.hashCode();
+        if (adType.equals("interstitial")) {
+            EAMaxInterstitialManager eAMaxInterstitialManager = new EAMaxInterstitialManager(appLovinSdk, this, this.mShouldSendImpressionData, this.mIsLoadedIgnoreFrequencyCapping);
+            GluEventBus gluEventBus = this.mEventBus;
+            if (gluEventBus != null) {
+                eAMaxInterstitialManager.subscribe(gluEventBus);
+            }
+            return eAMaxInterstitialManager;
+        }
+        if (adType.equals(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
+            EAMaxRVManager eAMaxRVManager = new EAMaxRVManager(appLovinSdk, this, this.mSeparator, this.mRewards, this.mShouldSendImpressionData, this.mIsLoadedIgnoreFrequencyCapping, this.mShouldIgnoreGlobalFrequencyCapping);
+            String str = this.mUserId.get();
+            if (str != null) {
+                eAMaxRVManager.setUserIdentifier(str, null);
+            }
+            String str2 = this.mGemsData.get();
+            if (str2 != null) {
+                eAMaxRVManager.internal_setGemsData(str2, null);
+            }
+            GluEventBus gluEventBus2 = this.mEventBus;
+            if (gluEventBus2 != null) {
+                eAMaxRVManager.subscribe(gluEventBus2);
+            }
+            return eAMaxRVManager;
+        }
+        return new DummyAdvertising();
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalArgumentException("SDK is initializing."), map);
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_FINISHED, new IllegalArgumentException("SDK is initializing."), map);
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+        this.mGemsData.set("");
+        this.mUserId.set(str);
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+        this.mUserId.set("");
+        this.mGemsData.set(str);
+    }
+}

decompiled/sources/csdk/gluads/max/EAMaxRVManager.java

@@ -0,0 +1,307 @@
+package csdk.gluads.max;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.applovin.mediation.MaxAd;
+import com.applovin.mediation.MaxError;
+import com.applovin.mediation.MaxReward;
+import com.applovin.mediation.MaxRewardedAdListener;
+import com.applovin.mediation.ads.MaxRewardedAd;
+import com.applovin.sdk.AppLovinSdk;
+import com.applovin.sdk.AppLovinSdkSettings;
+import com.facebook.share.internal.ShareConstants;
+import com.ironsource.nb;
+import csdk.gluads.Consts;
+import csdk.gluads.GemsDataUtil;
+import csdk.gluads.Reward;
+import csdk.gluads.max.EAMaxManagerBase;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.JsonUtil;
+import csdk.gluads.util.PlacementInfo;
+import csdk.gluads.util.RewardUtil;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class EAMaxRVManager extends EAMaxManagerBase {
+    private boolean mHasUserID;
+    private boolean mIsLoadedIgnoreFrequencyCapping;
+    private final AtomicReference<String> mRewardSource;
+    private final Map<String, Object> mRewards;
+    private final Map<String, Object> mSdkData;
+    private boolean mSendImpressionData;
+    private final String mSeparator;
+    private boolean mShouldIgnoreGlobalFrequencyCapping;
+
+    @Override // csdk.gluads.max.EAMaxManagerBase
+    public String adType() {
+        return Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL;
+    }
+
+    public class EAMaxRVListener extends EAMaxManagerBase.EAMaxListener implements MaxRewardedAdListener {
+        public EAMaxRVListener() {
+            super();
+        }
+
+        @Override // com.applovin.mediation.MaxRewardedAdListener
+        public void onUserRewarded(MaxAd maxAd, MaxReward maxReward) {
+            int amount = maxReward.getAmount();
+            String label = maxReward.getLabel();
+            String[] split = maxAd.getPlacement().split(EAMaxRVManager.this.mSeparator);
+            if (split.length > 1) {
+                label = split[0];
+                amount = Integer.parseInt(split[1]);
+            }
+            if (amount <= 0) {
+                EAMaxRVManager eAMaxRVManager = EAMaxRVManager.this;
+                Reward reward = eAMaxRVManager.getReward(eAMaxRVManager.adType(), "defaultReward");
+                if (reward != null) {
+                    label = reward.item;
+                    amount = reward.amount;
+                }
+            }
+            int i = amount;
+            if (i <= 0) {
+                ((EAMaxManagerBase) EAMaxRVManager.this).mLog.e("REWARDED_INTERSTITIAL.REWARD", nb.q, showingPlacement(), "Skipping reward callback because no valid reward amount can be determined");
+                return;
+            }
+            ((EAMaxManagerBase) EAMaxRVManager.this).mLog.d("REWARDED_INTERSTITIAL.REWARD", nb.q, showingPlacement(), "reward", label, "amount", Integer.valueOf(i));
+            EAMaxRVManager.this.listener().onRewardReceived(new Reward(Common.uuid(), showingPlacement(), "max", EAMaxRVManager.this.adType(), label, i));
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdLoaded(MaxAd maxAd) {
+            sendLoadPlacementEvent(Consts.PLACEMENT_STATUS_LOAD_FINISHED, null, null);
+            clearLoadingPlacements();
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdDisplayed(MaxAd maxAd) {
+            EAMaxRVManager.this.getCrossPromos().remove(maxAd.getPlacement());
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdHidden(MaxAd maxAd) {
+            EAMaxRVManager.this.frequencyController().increaseCount(EAMaxRVManager.this.isCrossPromo(maxAd.getAdUnitId()), showingPlacement());
+            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, null);
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdClicked(MaxAd maxAd) {
+            Map<String, Object> createMap = Common.createMap();
+            createMap.putAll(this.mExtra);
+            if (EAMaxRVManager.this.isCrossPromo(maxAd.getAdUnitId())) {
+                createMap.put(Consts.IS_CROSS_PROMO, 1);
+                Map<String, Object> map = ConfigUtil.getMap(EAMaxRVManager.this.getImpressionMapping(), maxAd.getAdUnitId());
+                if (map != null) {
+                    createMap.putAll(map);
+                }
+            }
+            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_CLICKED, null, createMap);
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdLoadFailed(String str, MaxError maxError) {
+            sendLoadPlacementEvent(Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalStateException("Failed to show ad: " + String.format("{code:%s, msg:%s, waterfall:%s}", Integer.valueOf(maxError.getCode()), maxError.getMessage(), maxError.getWaterfall()), new Throwable(String.valueOf(maxError.getCode()))));
+            clearLoadingPlacements();
+        }
+
+        @Override // com.applovin.mediation.MaxAdListener
+        public void onAdDisplayFailed(MaxAd maxAd, MaxError maxError) {
+            sendSinglePlacementEvent(showingPlacement(), Consts.PLACEMENT_STATUS_SHOW_FINISHED, new IllegalStateException("Failed to show ad: " + maxError.toString()));
+        }
+    }
+
+    public EAMaxRVManager(@NonNull AppLovinSdk appLovinSdk, EAMaxManagerBase eAMaxManagerBase, String str, Map<String, Object> map, boolean z, boolean z2, boolean z3) {
+        super(appLovinSdk, eAMaxManagerBase);
+        this.mHasUserID = false;
+        this.mSeparator = str;
+        AtomicReference<String> atomicReference = new AtomicReference<>("DEFAULT");
+        this.mRewardSource = atomicReference;
+        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
+        this.mRewards = concurrentHashMap;
+        this.mSdkData = Common.createMap();
+        if (map != null) {
+            synchronized (concurrentHashMap) {
+                concurrentHashMap.putAll(map);
+            }
+            atomicReference.set(map.isEmpty() ? "DEFAULT" : "SDK (client)");
+        }
+        this.mSendImpressionData = z;
+        this.mIsLoadedIgnoreFrequencyCapping = z2;
+        this.mShouldIgnoreGlobalFrequencyCapping = z3;
+        if (z3) {
+            return;
+        }
+        frequencyController().enableGlobalFrequencyCapping();
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+        ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SET.USERID", Consts.KEY_TAPJOY_USER_ID_VERSION, str, "l", "max");
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        getSdk().setUserIdentifier(str);
+        this.mHasUserID = true;
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+        ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SET.GEMSDATA", Consts.KEY_TAPJOY_USER_ID_VERSION, str, "l", "max");
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        try {
+            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
+            String string = ConfigUtil.getString(parseJsonObject, "sessionId");
+            if (!TextUtils.isEmpty(string)) {
+                parseJsonObject.remove("sessionId");
+                this.mSdkData.put("sessionId", string);
+            }
+            getSdk().setUserIdentifier(GemsDataUtil.base64EncodeMap(parseJsonObject));
+            this.mHasUserID = true;
+        } catch (JSONException e) {
+            ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SET.GEMSDATA", "e", e, "l", "max");
+        }
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        MaxRewardedAd maxRewardedAd;
+        if (!this.mHasUserID) {
+            return false;
+        }
+        String adUnitId = getAdUnitId(str2);
+        if (TextUtils.isEmpty(adUnitId) || (maxRewardedAd = MaxRewardedAd.getInstance(adUnitId, getSdk(), getActivity())) == null || !maxRewardedAd.isReady()) {
+            return false;
+        }
+        return this.mIsLoadedIgnoreFrequencyCapping || !isCapped(str2);
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        Object obj;
+        synchronized (this.mRewards) {
+            obj = this.mRewards.get(str2);
+        }
+        if (obj == null || !(obj instanceof Map)) {
+            return null;
+        }
+        return RewardUtil.toReward(str2, obj);
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+        synchronized (this.mRewards) {
+            this.mRewards.clear();
+            this.mRewards.putAll(map);
+        }
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        if (TextUtils.equals(str2, Consts.DEBUG_PLACEMENT)) {
+            getSdk().showMediationDebugger();
+            return;
+        }
+        if (!this.mHasUserID) {
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_STARTED, new IllegalArgumentException("UserId is empty."), map);
+            return;
+        }
+        String adUnitId = getAdUnitId(str2, false);
+        if (TextUtils.isEmpty(adUnitId)) {
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalArgumentException("No mapping for " + str2 + Consts.STRING_PERIOD), map);
+            return;
+        }
+        if (crossPromoMappingContains(adUnitId).booleanValue()) {
+            loadAdOnCrossPromoTargetAppCheck(str2, ConfigUtil.getString(ConfigUtil.getMap(getImpressionMapping(), adUnitId), "campaign_name"), map);
+        } else {
+            directLoad(str2, map);
+        }
+    }
+
+    @Override // csdk.gluads.eventbus.GluAdsManagerEventHandler
+    public void directLoad(String str, @NonNull Map<String, Object> map) {
+        if (TextUtils.equals(str, Consts.DEBUG_PLACEMENT)) {
+            getSdk().showMediationDebugger();
+            return;
+        }
+        String adUnitId = getAdUnitId(str);
+        MaxRewardedAd maxRewardedAd = MaxRewardedAd.getInstance(adUnitId, getSdk(), getActivity());
+        if (maxRewardedAd == null) {
+            sendPlacementEvent(str, Consts.PLACEMENT_STATUS_LOAD_FINISHED, new IllegalArgumentException("Not able to get instance for ad unit ID" + adUnitId + Consts.STRING_PERIOD), map);
+            return;
+        }
+        if (maxRewardedAd.isReady()) {
+            sendPlacementEvent(str, Consts.PLACEMENT_STATUS_LOAD_FINISHED, null, map);
+            return;
+        }
+        if (crossPromoMappingContains(adUnitId).booleanValue()) {
+            setCrossPromoLoaded(adUnitId);
+        }
+        EAMaxManagerBase.EAMaxListener listenerForAdUnitId = getListenerForAdUnitId(adUnitId);
+        EAMaxManagerBase.EAMaxListener eAMaxListener = listenerForAdUnitId;
+        if (listenerForAdUnitId == null) {
+            EAMaxRVListener eAMaxRVListener = new EAMaxRVListener();
+            addListenerForAdUnitId(eAMaxRVListener, adUnitId);
+            maxRewardedAd.setListener(eAMaxRVListener);
+            eAMaxListener = eAMaxRVListener;
+        }
+        eAMaxListener.addLoadingPlacement(str);
+        AppLovinSdkSettings settings = getSdk().getSettings();
+        String string = ConfigUtil.getString(map, Consts.MAX_TEST_MODE_NETWORK);
+        if (string != null) {
+            settings.setExtraParameter(Consts.MAX_TEST_MODE_NETWORK, string);
+        } else if (isTestPlacement(str)) {
+            settings.setExtraParameter(Consts.MAX_TEST_MODE_NETWORK, getTestNetwork(str));
+        }
+        maxRewardedAd.loadAd();
+    }
+
+    @Override // csdk.gluads.max.EAMaxManagerBase, csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        if (TextUtils.equals(str2, Consts.DEBUG_PLACEMENT)) {
+            getSdk().showMediationDebugger();
+            return;
+        }
+        if (isLoaded(str, str2, map)) {
+            String str3 = null;
+            sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_ATTEMPT, null, map);
+            String adUnitId = getAdUnitId(str2);
+            MaxRewardedAd maxRewardedAd = MaxRewardedAd.getInstance(adUnitId, getSdk(), getActivity());
+            PlacementInfo placement = RewardUtil.getPlacement(new PlacementInfo(this.mRewardSource.get(), str2), this.mRewards, map, this.mSeparator);
+            String str4 = placement.mName;
+            ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SHOW", Consts.KEY_TAPJOY_USER_ID_VERSION, str4, ShareConstants.FEED_SOURCE_PARAM, placement.mSource, "l", "max");
+            Map createMap = Common.createMap();
+            if (map != null) {
+                String string = ConfigUtil.getString(map, Consts.MEDIATION_CUSTOM_DATA);
+                if (!TextUtils.isEmpty(string)) {
+                    createMap.put(Consts.KEY_NAME_GAMEDATA, string);
+                }
+            }
+            if (!this.mSdkData.isEmpty()) {
+                createMap.put(Consts.MEDIATION_CUSTOM_DATA, JsonUtil.toJson(this.mSdkData));
+            }
+            if (!createMap.isEmpty()) {
+                str3 = GemsDataUtil.base64EncodeMap(createMap);
+                ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.SHOW", nb.q, str2, "customParams", JsonUtil.toJson(createMap));
+            }
+            EAMaxManagerBase.EAMaxListener listenerForAdUnitId = getListenerForAdUnitId(adUnitId);
+            if (listenerForAdUnitId != null) {
+                listenerForAdUnitId.setShowingPlacement(str2);
+            }
+            if (isCrossPromo(adUnitId)) {
+                ((EAMaxManagerBase) this).mLog.d("REWARDED_INTERSTITIAL.LOAD", Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "placement", adUnitId, "adUnitID", "max");
+            }
+            maxRewardedAd.setRevenueListener(makeRevenueListener(str2, map, this.mSendImpressionData));
+            maxRewardedAd.showAd(str4, str3);
+            return;
+        }
+        sendPlacementEvent(str2, Consts.PLACEMENT_STATUS_SHOW_STARTED, new IllegalStateException("Not ready"), map);
+    }
+}

decompiled/sources/csdk/gluads/max/EAPlacementListener.java

@@ -0,0 +1,16 @@
+package csdk.gluads.max;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class EAPlacementListener {
+    private AtomicReference<String> mShowingPlacement = new AtomicReference<>("");
+
+    public void setShowingPlacement(String str) {
+        this.mShowingPlacement.set(str);
+    }
+
+    public String showingPlacement() {
+        return this.mShowingPlacement.get();
+    }
+}

decompiled/sources/csdk/gluads/tapjoy/TapjoyConnectState.java

@@ -0,0 +1,26 @@
+package csdk.gluads.tapjoy;
+
+/* loaded from: classes4.dex */
+public class TapjoyConnectState {
+    private boolean mIsConnecting = false;
+    private Listener mListener = null;
+
+    public interface Listener {
+        void onConnectStateChange(boolean z);
+    }
+
+    public void set(boolean z) {
+        this.mIsConnecting = z;
+        Listener listener = this.mListener;
+        if (listener != null) {
+            listener.onConnectStateChange(z);
+        }
+    }
+
+    public void setListener(Listener listener) {
+        this.mListener = listener;
+        if (listener != null) {
+            listener.onConnectStateChange(this.mIsConnecting);
+        }
+    }
+}

decompiled/sources/csdk/gluads/tapjoy/TapjoyOfferWallManager.java

@@ -0,0 +1,316 @@
+package csdk.gluads.tapjoy;
+
+import android.app.Activity;
+import android.content.Context;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.tapjoy.TJActionRequest;
+import com.tapjoy.TJError;
+import com.tapjoy.TJPlacement;
+import com.tapjoy.TJPlacementListener;
+import com.tapjoy.TJSetUserIDListener;
+import com.tapjoy.Tapjoy;
+import csdk.gluads.Consts;
+import csdk.gluads.GemsDataUtil;
+import csdk.gluads.IAdvertising;
+import csdk.gluads.IAdvertisingListener;
+import csdk.gluads.LoadingScreen;
+import csdk.gluads.PlacementEvent;
+import csdk.gluads.PrivacyStatus;
+import csdk.gluads.Reward;
+import csdk.gluads.impl.NullAdvertisingListener;
+import csdk.gluads.tapjoy.TapjoyConnectState;
+import csdk.gluads.util.AdvertisingUtil;
+import csdk.gluads.util.Common;
+import csdk.gluads.util.ConfigUtil;
+import csdk.gluads.util.JsonUtil;
+import csdk.gluads.util.log.YLogger;
+import csdk.gluads.util.log.YLoggerFactory;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public class TapjoyOfferWallManager implements IAdvertising, TapjoyConnectState.Listener {
+    private static final int TAPJOY_MINIMUM_WORKING_API_LEVEL = 24;
+    private final Activity mActivity;
+    private final Context mApplicationContext;
+    private final String mDefaultPlacementId;
+    private final AtomicReference<String> mEncodedGemsPayload;
+    private final Map<String, Object> mExtra;
+    private final LoadingScreen mLoadingScreen;
+    private final Map<String, String> mPlacementToPlacementId;
+    private final AtomicReference<String> mUserIdentifier;
+    private final YLogger mLog = YLoggerFactory.getLogger(getClass());
+    private final AtomicReference<IAdvertisingListener> mListener = new AtomicReference<>(NullAdvertisingListener.INSTANCE);
+
+    @Override // csdk.gluads.IAdvertising
+    public void discard(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public Reward getReward(@NonNull String str, @NonNull String str2) {
+        return null;
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_onNewSession() {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateAdsFrequency(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateCrossPromotion(@NonNull String str, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updatePrivacyStatus(PrivacyStatus privacyStatus) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_updateRewardList(@NonNull Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void load(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementClick(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onAdvertisementImpression(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setCustomProperties(@Nullable Map<String, Object> map) {
+    }
+
+    public TapjoyOfferWallManager(Callable<Activity> callable, Map<String, String> map, String str, LoadingScreen loadingScreen) {
+        Map<String, String> createMap = Common.createMap();
+        this.mPlacementToPlacementId = createMap;
+        createMap.putAll(map);
+        this.mDefaultPlacementId = str;
+        this.mLoadingScreen = loadingScreen;
+        Map<String, Object> createMap2 = Common.createMap();
+        this.mExtra = createMap2;
+        createMap2.put(Consts.MEDIATION_NETWORK, Consts.SDK_TAPJOY);
+        this.mUserIdentifier = new AtomicReference<>(null);
+        this.mEncodedGemsPayload = new AtomicReference<>(null);
+        Activity activity = (Activity) Common.call(callable);
+        this.mActivity = activity;
+        this.mApplicationContext = activity.getApplicationContext();
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public boolean isLoaded(@NonNull String str, @NonNull String str2, @Nullable Map<String, Object> map) {
+        return Tapjoy.isConnected();
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void show(@NonNull String str, @NonNull final String str2, @Nullable Map<String, Object> map) {
+        this.mLog.d("OFFER_WALL.SHOW", "l", Consts.SDK_TAPJOY, "placement", str2);
+        final String str3 = (String) Common.get(this.mPlacementToPlacementId, str2, this.mDefaultPlacementId);
+        if (!Tapjoy.isConnected()) {
+            onOfferWallShowFailed(str2, new Exception("Tapjoy is not connected."));
+            return;
+        }
+        if (TextUtils.isEmpty(str3)) {
+            onOfferWallShowFailed(str2, new IllegalArgumentException("No mapping for " + str2));
+            return;
+        }
+        String str4 = this.mUserIdentifier.get();
+        String str5 = this.mEncodedGemsPayload.get();
+        if (TextUtils.isEmpty(str4)) {
+            onOfferWallShowFailed(str2, new IllegalArgumentException("UserId is empty."));
+            return;
+        }
+        if (TextUtils.isEmpty(str5)) {
+            onOfferWallShowFailed(str2, new IllegalArgumentException("GemsPayload is empty."));
+            return;
+        }
+        Common.runOnUIThread(new Runnable() { // from class: csdk.gluads.tapjoy.TapjoyOfferWallManager.1
+            @Override // java.lang.Runnable
+            public void run() {
+                TapjoyOfferWallManager.this.mLoadingScreen.show();
+            }
+        });
+        this.mLog.d("OFFER_WALL.SHOW.SET_CUSTOM_PARAM", "l", Consts.SDK_TAPJOY, "customParam", str5);
+        Tapjoy.setCustomParameter(str5);
+        this.mLog.d("OFFER_WALL.SHOW.SET_USER_ID", "l", Consts.SDK_TAPJOY, "userId", str4);
+        Tapjoy.setUserID(str4, new TJSetUserIDListener() { // from class: csdk.gluads.tapjoy.TapjoyOfferWallManager.2
+            @Override // com.tapjoy.TJSetUserIDListener
+            public void onSetUserIDSuccess() {
+                Tapjoy.setActivity(TapjoyOfferWallManager.this.mActivity);
+                TJPlacement placement = Tapjoy.getPlacement(str3, TapjoyOfferWallManager.this.new TapjoyListener(str2));
+                AdvertisingUtil.broadcastNetworkIntent(TapjoyOfferWallManager.this.mApplicationContext, Consts.SDK_TAPJOY);
+                placement.requestContent();
+            }
+
+            @Override // com.tapjoy.TJSetUserIDListener
+            public void onSetUserIDFailure(String str6) {
+                TapjoyOfferWallManager.this.mLoadingScreen.dismiss();
+                TapjoyOfferWallManager.this.onOfferWallShowFailed(str2, new IllegalArgumentException("Set UserId failed: " + str6));
+            }
+        });
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setAdvertisingListener(@Nullable IAdvertisingListener iAdvertisingListener) {
+        AtomicReference<IAdvertisingListener> atomicReference = this.mListener;
+        if (iAdvertisingListener == null) {
+            iAdvertisingListener = NullAdvertisingListener.INSTANCE;
+        }
+        atomicReference.set(iAdvertisingListener);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void destroy() {
+        onPause();
+        this.mListener.set(NullAdvertisingListener.INSTANCE);
+        onConnectStateChange(false);
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onPause() {
+        this.mLoadingScreen.dismiss();
+        if (Tapjoy.isConnected()) {
+            Tapjoy.endSession();
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void onResume() {
+        if (Tapjoy.isConnected()) {
+            Tapjoy.startSession();
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void setUserIdentifier(@Nullable String str, @Nullable Map<String, Object> map) {
+        this.mLog.d("OFFER_WALL.UPDATE.USER_ID", "l", Consts.SDK_TAPJOY, "userId", str);
+        if (TextUtils.isEmpty(str)) {
+            this.mUserIdentifier.set(null);
+        } else {
+            this.mUserIdentifier.set(str);
+        }
+    }
+
+    private void setGemsAnalyticsIdentifiers(@Nullable Map<String, Object> map) {
+        this.mLog.d("OFFER_WALL.UPDATE.GEMS_ANALYTICS_IDS", "l", Consts.SDK_TAPJOY, "data", map);
+        if (map == null || map.isEmpty()) {
+            this.mEncodedGemsPayload.set(null);
+        } else {
+            this.mEncodedGemsPayload.set(GemsDataUtil.base64EncodeMap(map));
+        }
+    }
+
+    @Override // csdk.gluads.IAdvertising
+    public void internal_setGemsData(@Nullable String str, @Nullable Map<String, Object> map) {
+        this.mLog.d("OFFER_WALL.UPDATE.GEMSDATA", "l", Consts.SDK_TAPJOY, Consts.KEY_NAME_GEMSDATA, str);
+        try {
+            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
+            String string = ConfigUtil.getString(parseJsonObject, "playerId", "");
+            String string2 = ConfigUtil.getString(parseJsonObject, Consts.KEY_NAME_ANALYTICS_DEVICE_ID, "");
+            String string3 = ConfigUtil.getString(parseJsonObject, Consts.KEY_NAME_ANALYTICS_GAME_NAME, "");
+            String string4 = ConfigUtil.getString(parseJsonObject, "sessionId", "");
+            String string5 = ConfigUtil.getString(parseJsonObject, "revId", "");
+            Map createMap = Common.createMap();
+            if (!TextUtils.isEmpty(string)) {
+                createMap.put(Consts.KEY_TAPJOY_USER_ID, string);
+                createMap.put(Consts.KEY_TAPJOY_USER_ID_VERSION, "2");
+                setUserIdentifier(GemsDataUtil.base64EncodeMap(createMap), null);
+            }
+            Map<String, Object> createMap2 = Common.createMap();
+            if (!TextUtils.isEmpty(string2)) {
+                createMap2.put(Consts.KEY_TAPJOY_ANALYTICS_DEVICE_ID, string2);
+            }
+            if (!TextUtils.isEmpty(string3)) {
+                createMap2.put("name", string3);
+            }
+            if (!TextUtils.isEmpty(string4)) {
+                createMap2.put(Consts.KEY_TAPJOY_SESSION_ID, string4);
+            }
+            if (!TextUtils.isEmpty(string5)) {
+                createMap2.put("revId", string5);
+            }
+            if (createMap2.isEmpty()) {
+                return;
+            }
+            setGemsAnalyticsIdentifiers(createMap2);
+        } catch (Exception e) {
+            this.mLog.d("OFFER_WALL.PARSE.GEMSDATA", "e", e, "l", Consts.SDK_TAPJOY);
+        }
+    }
+
+    @Override // csdk.gluads.tapjoy.TapjoyConnectState.Listener
+    public void onConnectStateChange(boolean z) {
+        this.mLog.d("OFFER_WALL", "l", Consts.SDK_TAPJOY, "Tapjoy is connecting", Boolean.valueOf(z));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onOfferWallShowFailed(String str, Exception exc) {
+        this.mLoadingScreen.dismiss();
+        this.mLog.e("OFFER_WALL.SHOW.ERROR", "l", Consts.SDK_TAPJOY, "placement", str, "e", exc);
+        this.mListener.get().onPlacementEvent(new PlacementEvent(Consts.ADVERTISEMENT_TYPE_OFFER_WALL, str, Consts.PLACEMENT_STATUS_SHOW_STARTED, exc, this.mExtra));
+    }
+
+    public class TapjoyListener implements TJPlacementListener {
+        private final String mPlacement;
+
+        @Override // com.tapjoy.TJPlacementListener
+        public void onPurchaseRequest(TJPlacement tJPlacement, TJActionRequest tJActionRequest, String str) {
+        }
+
+        @Override // com.tapjoy.TJPlacementListener
+        public void onRequestSuccess(TJPlacement tJPlacement) {
+        }
+
+        @Override // com.tapjoy.TJPlacementListener
+        public void onRewardRequest(TJPlacement tJPlacement, TJActionRequest tJActionRequest, String str, int i) {
+        }
+
+        public TapjoyListener(String str) {
+            this.mPlacement = str;
+        }
+
+        @Override // com.tapjoy.TJPlacementListener
+        public void onRequestFailure(TJPlacement tJPlacement, TJError tJError) {
+            TapjoyOfferWallManager.this.onOfferWallShowFailed(this.mPlacement, new Exception(tJError.message));
+        }
+
+        @Override // com.tapjoy.TJPlacementListener
+        public void onContentReady(TJPlacement tJPlacement) {
+            if (tJPlacement.isContentAvailable()) {
+                if (TapjoyOfferWallManager.this.mLoadingScreen.isInitialized() && !TapjoyOfferWallManager.this.mLoadingScreen.isShowing()) {
+                    onContentDismiss(tJPlacement);
+                    return;
+                } else {
+                    tJPlacement.showContent();
+                    return;
+                }
+            }
+            onRequestFailure(tJPlacement, new TJError(0, "Content is not available for " + tJPlacement.getName()));
+        }
+
+        @Override // com.tapjoy.TJPlacementListener
+        public void onContentShow(TJPlacement tJPlacement) {
+            TapjoyOfferWallManager.this.mLoadingScreen.dismiss();
+            ((IAdvertisingListener) TapjoyOfferWallManager.this.mListener.get()).onPlacementEvent(new PlacementEvent(Consts.ADVERTISEMENT_TYPE_OFFER_WALL, this.mPlacement, Consts.PLACEMENT_STATUS_SHOW_STARTED, null, TapjoyOfferWallManager.this.mExtra));
+        }
+
+        @Override // com.tapjoy.TJPlacementListener
+        public void onContentDismiss(TJPlacement tJPlacement) {
+            ((IAdvertisingListener) TapjoyOfferWallManager.this.mListener.get()).onPlacementEvent(new PlacementEvent(Consts.ADVERTISEMENT_TYPE_OFFER_WALL, this.mPlacement, Consts.PLACEMENT_STATUS_SHOW_FINISHED, null, TapjoyOfferWallManager.this.mExtra));
+        }
+
+        @Override // com.tapjoy.TJPlacementListener
+        public void onClick(TJPlacement tJPlacement) {
+            ((IAdvertisingListener) TapjoyOfferWallManager.this.mListener.get()).onPlacementEvent(new PlacementEvent(Consts.ADVERTISEMENT_TYPE_OFFER_WALL, this.mPlacement, Consts.PLACEMENT_STATUS_CLICKED, null, null));
+        }
+    }
+}

decompiled/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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));
+    }
+}

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