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