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