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/com/ironsource/adapters/admob/AdMobAdapter.java

@@ -0,0 +1,376 @@
+package com.ironsource.adapters.admob;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.google.android.gms.ads.AdFormat;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.MobileAds;
+import com.google.android.gms.ads.RequestConfiguration;
+import com.google.android.gms.ads.initialization.AdapterStatus;
+import com.google.android.gms.ads.initialization.InitializationStatus;
+import com.google.android.gms.ads.initialization.OnInitializationCompleteListener;
+import com.google.android.gms.ads.query.QueryInfo;
+import com.google.android.gms.ads.query.QueryInfoGenerationCallback;
+import com.ironsource.adapters.admob.banner.AdMobBannerAdapter;
+import com.ironsource.adapters.admob.interstitial.AdMobInterstitialAdapter;
+import com.ironsource.adapters.admob.nativead.AdMobNativeAdAdapter;
+import com.ironsource.adapters.admob.rewardedvideo.AdMobRewardedVideoAdapter;
+import com.ironsource.environment.ContextProvider;
+import com.ironsource.environment.StringUtils;
+import com.ironsource.mediationsdk.AbstractAdapter;
+import com.ironsource.mediationsdk.INetworkInitCallbackListener;
+import com.ironsource.mediationsdk.IntegrationData;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.LoadWhileShowSupportState;
+import com.ironsource.mediationsdk.bidding.BiddingDataCallback;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.metadata.MetaData;
+import com.ironsource.mediationsdk.metadata.MetaDataUtils;
+import com.tapjoy.TapjoyConstants;
+import csdk.gluads.ironsource.EAIronSource;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class AdMobAdapter extends AbstractAdapter {
+    private static final String AD_UNIT_ID = "adUnitId";
+    private static final String EMPTY_STRING = "";
+    private static final String GitHash = "6c36c81";
+    private static final String VERSION = "4.3.45";
+    private static Boolean mCCPAValue = null;
+    private static Boolean mConsent = null;
+    private static String mContentMappingURLValue = "";
+    private static Integer mCoppaValue = null;
+    private static Integer mEuValue = null;
+    private static String mRatingValue = "";
+    private final String INIT_RESPONSE_REQUIRED;
+    private final String NETWORK_ONLY_INIT;
+    private final String PLATFORM_NAME;
+    private final String REQUEST_AGENT;
+    private static List<String> mNeighboringContentMappingURLValue = new ArrayList();
+    private static final HashSet<INetworkInitCallbackListener> initCallbackListeners = new HashSet<>();
+    public static InitState mInitState = InitState.INIT_STATE_NONE;
+    private static final AtomicBoolean mWasInitCalled = new AtomicBoolean(false);
+
+    public interface AdMobMaxContentRating {
+        public static final String ADMOB_MAX_AD_CONTENT_RATING_G = "max_ad_content_rating_g";
+        public static final String ADMOB_MAX_AD_CONTENT_RATING_MA = "max_ad_content_rating_ma";
+        public static final String ADMOB_MAX_AD_CONTENT_RATING_PG = "max_ad_content_rating_pg";
+        public static final String ADMOB_MAX_AD_CONTENT_RATING_T = "max_ad_content_rating_t";
+    }
+
+    public interface AdMobMetaDataFlags {
+        public static final String ADMOB_CONTENT_MAPPING_KEY = "google_content_mapping";
+        public static final String ADMOB_MAX_RATING_KEY = "admob_maxcontentrating";
+        public static final String ADMOB_TFCD_KEY = "admob_tfcd";
+        public static final String ADMOB_TFUA_KEY = "admob_tfua";
+    }
+
+    public enum InitState {
+        INIT_STATE_NONE,
+        INIT_STATE_IN_PROGRESS,
+        INIT_STATE_SUCCESS,
+        INIT_STATE_FAILED
+    }
+
+    public static boolean isNoFillError(int i) {
+        return i == 3 || i == 9;
+    }
+
+    public String getAdUnitIdKey() {
+        return "adUnitId";
+    }
+
+    public InitState getInitState() {
+        return mInitState;
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public String getVersion() {
+        return VERSION;
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public boolean isUsingActivityBeforeImpression(IronSource.AD_UNIT ad_unit) {
+        return false;
+    }
+
+    public static AdMobAdapter startAdapter(String str) {
+        if (EAIronSource.adapterDisabled(AdMobAdapter.class.getName())) {
+            return null;
+        }
+        return new AdMobAdapter(str);
+    }
+
+    private AdMobAdapter(String str) {
+        super(str);
+        this.REQUEST_AGENT = TapjoyConstants.TJC_PLUGIN_UNITY;
+        this.PLATFORM_NAME = TapjoyConstants.TJC_PLUGIN_UNITY;
+        this.NETWORK_ONLY_INIT = "networkOnlyInit";
+        this.INIT_RESPONSE_REQUIRED = "initResponseRequired";
+        IronLog.INTERNAL.verbose();
+        setRewardedVideoAdapter(new AdMobRewardedVideoAdapter(this));
+        setInterstitialAdapter(new AdMobInterstitialAdapter(this));
+        setBannerAdapter(new AdMobBannerAdapter(this));
+        setNativeAdAdapter(new AdMobNativeAdAdapter(this));
+        this.mLWSSupportState = LoadWhileShowSupportState.LOAD_WHILE_SHOW_BY_INSTANCE;
+    }
+
+    public static IntegrationData getIntegrationData(Context context) {
+        return new IntegrationData("AdMob", VERSION);
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public String getCoreSDKVersion() {
+        return getAdapterSDKVersion();
+    }
+
+    public static String getAdapterSDKVersion() {
+        return MobileAds.getVersion().toString();
+    }
+
+    public void initSDK(JSONObject jSONObject) {
+        if (mInitState == InitState.INIT_STATE_NONE || mInitState == InitState.INIT_STATE_IN_PROGRESS) {
+            initCallbackListeners.add(this);
+        }
+        if (mWasInitCalled.compareAndSet(false, true)) {
+            mInitState = InitState.INIT_STATE_IN_PROGRESS;
+            IronLog ironLog = IronLog.ADAPTER_API;
+            ironLog.verbose();
+            if (jSONObject.optBoolean("networkOnlyInit", true)) {
+                ironLog.verbose("disableMediationAdapterInitialization");
+                MobileAds.disableMediationAdapterInitialization(ContextProvider.getInstance().getApplicationContext());
+            }
+            if (jSONObject.optBoolean("initResponseRequired", false)) {
+                ironLog.verbose("init and wait for callback");
+                MobileAds.initialize(ContextProvider.getInstance().getApplicationContext(), new OnInitializationCompleteListener() { // from class: com.ironsource.adapters.admob.AdMobAdapter.1
+                    @Override // com.google.android.gms.ads.initialization.OnInitializationCompleteListener
+                    public void onInitializationComplete(InitializationStatus initializationStatus) {
+                        AdapterStatus adapterStatus = initializationStatus.getAdapterStatusMap().get("com.google.android.gms.ads.MobileAds");
+                        if ((adapterStatus != null ? adapterStatus.getInitializationState() : null) == AdapterStatus.State.READY) {
+                            IronLog.ADAPTER_API.verbose("initializationStatus = READY");
+                            AdMobAdapter.this.initializationSuccess();
+                        } else {
+                            IronLog.ADAPTER_API.verbose("initializationStatus = NOT READY");
+                            AdMobAdapter.this.initializationFailure();
+                        }
+                    }
+                });
+            } else {
+                ironLog.verbose("init without callback");
+                MobileAds.initialize(ContextProvider.getInstance().getApplicationContext());
+                initializationSuccess();
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void initializationSuccess() {
+        mInitState = InitState.INIT_STATE_SUCCESS;
+        Iterator<INetworkInitCallbackListener> it = initCallbackListeners.iterator();
+        while (it.hasNext()) {
+            it.next().onNetworkInitCallbackSuccess();
+        }
+        initCallbackListeners.clear();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void initializationFailure() {
+        mInitState = InitState.INIT_STATE_FAILED;
+        Iterator<INetworkInitCallbackListener> it = initCallbackListeners.iterator();
+        while (it.hasNext()) {
+            it.next().onNetworkInitCallbackFailed("AdMob sdk init failed");
+        }
+        initCallbackListeners.clear();
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public void setConsent(boolean z) {
+        IronLog.ADAPTER_API.verbose("consent = " + z);
+        mConsent = Boolean.valueOf(z);
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public void setMetaData(String str, List<String> list) {
+        if (list.isEmpty()) {
+            return;
+        }
+        if (list.size() > 1 && str.equalsIgnoreCase(AdMobMetaDataFlags.ADMOB_CONTENT_MAPPING_KEY)) {
+            mNeighboringContentMappingURLValue = list;
+            IronLog.ADAPTER_API.verbose("key = " + str + ", values = " + list);
+            return;
+        }
+        String str2 = list.get(0);
+        IronLog.ADAPTER_API.verbose("key = " + str + ", value = " + str2);
+        if (MetaDataUtils.isValidCCPAMetaData(str, str2)) {
+            setCCPAValue(MetaDataUtils.getMetaDataBooleanValue(str2));
+        } else {
+            setAdMobMetaDataValue(StringUtils.toLowerCase(str), StringUtils.toLowerCase(str2));
+        }
+    }
+
+    private void setCCPAValue(boolean z) {
+        IronLog.ADAPTER_API.verbose("value = " + z);
+        mCCPAValue = Boolean.valueOf(z);
+    }
+
+    private void setAdMobMetaDataValue(String str, String str2) {
+        String formatValueForType;
+        if (AdMobMetaDataFlags.ADMOB_TFCD_KEY.equals(str) || AdMobMetaDataFlags.ADMOB_TFUA_KEY.equals(str)) {
+            formatValueForType = MetaDataUtils.formatValueForType(str2, MetaData.MetaDataValueTypes.META_DATA_VALUE_BOOLEAN);
+            if (TextUtils.isEmpty(formatValueForType)) {
+                IronLog.ADAPTER_API.verbose("MetaData value for key " + str + " is invalid " + str2);
+                return;
+            }
+        } else {
+            formatValueForType = str2;
+        }
+        str.hashCode();
+        switch (str) {
+            case "google_content_mapping":
+                mContentMappingURLValue = str2;
+                IronLog.ADAPTER_API.verbose("key = " + str + ", contentMappingValue = " + mContentMappingURLValue);
+                break;
+            case "admob_maxcontentrating":
+                mRatingValue = getAdMobRatingValue(formatValueForType);
+                IronLog.ADAPTER_API.verbose("key = " + str + ", ratingValue = " + mRatingValue);
+                break;
+            case "admob_tfcd":
+                mCoppaValue = Integer.valueOf(getAdMobCoppaValue(formatValueForType));
+                IronLog.ADAPTER_API.verbose("key = " + str + ", coppaValue = " + mCoppaValue);
+                break;
+            case "admob_tfua":
+                mEuValue = Integer.valueOf(getAdMobEuValue(formatValueForType));
+                IronLog.ADAPTER_API.verbose("key = " + str + ", euValue = " + mEuValue);
+                break;
+        }
+        setRequestConfiguration();
+    }
+
+    private int getAdMobCoppaValue(String str) {
+        return MetaDataUtils.getMetaDataBooleanValue(str) ? 1 : 0;
+    }
+
+    private int getAdMobEuValue(String str) {
+        return MetaDataUtils.getMetaDataBooleanValue(str) ? 1 : 0;
+    }
+
+    private String getAdMobRatingValue(String str) {
+        if (TextUtils.isEmpty(str)) {
+            IronLog.INTERNAL.error("The ratingValue is null");
+            return null;
+        }
+        str.hashCode();
+        switch (str) {
+            case "max_ad_content_rating_ma":
+                return RequestConfiguration.MAX_AD_CONTENT_RATING_MA;
+            case "max_ad_content_rating_pg":
+                return RequestConfiguration.MAX_AD_CONTENT_RATING_PG;
+            case "max_ad_content_rating_g":
+                return RequestConfiguration.MAX_AD_CONTENT_RATING_G;
+            case "max_ad_content_rating_t":
+                return RequestConfiguration.MAX_AD_CONTENT_RATING_T;
+            default:
+                IronLog.INTERNAL.error("The ratingValue = " + str + " is undefine");
+                return "";
+        }
+    }
+
+    public AdRequest createAdRequest(JSONObject jSONObject, String str) {
+        AdRequest.Builder builder = new AdRequest.Builder();
+        builder.setRequestAgent(TapjoyConstants.TJC_PLUGIN_UNITY);
+        if (str != null) {
+            builder.setAdString(str);
+        }
+        Bundle bundle = new Bundle();
+        bundle.putString("platform_name", TapjoyConstants.TJC_PLUGIN_UNITY);
+        boolean z = false;
+        if (jSONObject != null) {
+            String optString = jSONObject.optString("requestId", "");
+            z = jSONObject.optBoolean("isHybrid", false);
+            if (!optString.isEmpty()) {
+                bundle.putString("placement_req_id", optString);
+                IronLog.INTERNAL.verbose("adData requestId = " + optString + ", isHybrid = " + z);
+            }
+        } else {
+            IronLog.INTERNAL.verbose("adData is null, using default hybridMode = false");
+        }
+        bundle.putString("is_hybrid_setup", String.valueOf(z));
+        setRequestConfiguration();
+        Boolean bool = mConsent;
+        if (bool != null || mCCPAValue != null) {
+            if (bool != null && !bool.booleanValue()) {
+                IronLog.ADAPTER_API.verbose("mConsent = " + mConsent);
+                bundle.putString("npa", "1");
+            }
+            if (mCCPAValue != null) {
+                IronLog.ADAPTER_API.verbose("mCCPAValue = " + mCCPAValue);
+                bundle.putInt("rdp", mCCPAValue.booleanValue() ? 1 : 0);
+            }
+        }
+        if (!TextUtils.isEmpty(mContentMappingURLValue)) {
+            IronLog.ADAPTER_API.verbose("mContentMappingURLValue = " + mContentMappingURLValue);
+            builder.setContentUrl(mContentMappingURLValue);
+        }
+        if (!mNeighboringContentMappingURLValue.isEmpty()) {
+            IronLog.ADAPTER_API.verbose("mNeighboringContentMappingURLValue = " + mNeighboringContentMappingURLValue);
+            builder.setNeighboringContentUrls(mNeighboringContentMappingURLValue);
+        }
+        builder.addNetworkExtrasBundle(com.google.ads.mediation.admob.AdMobAdapter.class, bundle);
+        return builder.build();
+    }
+
+    private void setRequestConfiguration() {
+        RequestConfiguration.Builder onAdMobLoadRequest = EAIronSource.onAdMobLoadRequest(MobileAds.getRequestConfiguration().toBuilder());
+        Integer num = mCoppaValue;
+        RequestConfiguration build = num != null ? onAdMobLoadRequest.setTagForChildDirectedTreatment(num.intValue()).build() : null;
+        Integer num2 = mEuValue;
+        if (num2 != null) {
+            build = onAdMobLoadRequest.setTagForUnderAgeOfConsent(num2.intValue()).build();
+        }
+        if (!TextUtils.isEmpty(mRatingValue)) {
+            build = onAdMobLoadRequest.setMaxAdContentRating(mRatingValue).build();
+        }
+        if (build != null) {
+            MobileAds.setRequestConfiguration(build);
+        }
+    }
+
+    public void collectBiddingData(final BiddingDataCallback biddingDataCallback, AdFormat adFormat, Bundle bundle) {
+        if (mInitState == InitState.INIT_STATE_NONE) {
+            IronLog.INTERNAL.verbose("returning null as token since init hasn't started");
+            biddingDataCallback.onFailure("returning null as token since init hasn't started - AdMob");
+            return;
+        }
+        Bundle bundle2 = new Bundle();
+        bundle2.putString("query_info_type", "requester_type_2");
+        if (bundle != null) {
+            bundle2.putAll(bundle);
+        }
+        IronLog.ADAPTER_API.verbose(adFormat.toString());
+        QueryInfo.generate(ContextProvider.getInstance().getApplicationContext(), adFormat, new AdRequest.Builder().setRequestAgent(TapjoyConstants.TJC_PLUGIN_UNITY).addNetworkExtrasBundle(com.google.ads.mediation.admob.AdMobAdapter.class, bundle2).build(), new QueryInfoGenerationCallback() { // from class: com.ironsource.adapters.admob.AdMobAdapter.2
+            @Override // com.google.android.gms.ads.query.QueryInfoGenerationCallback
+            public void onSuccess(@NonNull QueryInfo queryInfo) {
+                String query = !TextUtils.isEmpty(queryInfo.getQuery()) ? queryInfo.getQuery() : "";
+                String coreSDKVersion = AdMobAdapter.this.getCoreSDKVersion();
+                IronLog.ADAPTER_API.verbose("token = " + query + ", sdkVersion = " + coreSDKVersion);
+                HashMap hashMap = new HashMap();
+                hashMap.put("token", query);
+                hashMap.put("sdkVersion", coreSDKVersion);
+                biddingDataCallback.onSuccess(hashMap);
+            }
+
+            @Override // com.google.android.gms.ads.query.QueryInfoGenerationCallback
+            public void onFailure(@NonNull String str) {
+                biddingDataCallback.onFailure("failed to receive token - AdMob " + str);
+            }
+        });
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/banner/AdMobBannerAdListener.java

@@ -0,0 +1,112 @@
+package com.ironsource.adapters.admob.banner;
+
+import android.widget.FrameLayout;
+import com.google.android.gms.ads.AdListener;
+import com.google.android.gms.ads.AdView;
+import com.google.android.gms.ads.LoadAdError;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.sdk.BannerSmashListener;
+import com.ironsource.mediationsdk.utils.ErrorBuilder;
+
+/* loaded from: classes2.dex */
+public class AdMobBannerAdListener extends AdListener {
+    private String mAdUnitId;
+    private AdView mAdView;
+    private BannerSmashListener mListener;
+
+    public AdMobBannerAdListener(BannerSmashListener bannerSmashListener, String str, AdView adView) {
+        this.mListener = bannerSmashListener;
+        this.mAdUnitId = str;
+        this.mAdView = adView;
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdLoaded() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            if (this.mAdView == null) {
+                IronLog.INTERNAL.verbose("adView is null");
+                return;
+            }
+            FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(-2, -2);
+            layoutParams.gravity = 17;
+            this.mListener.onBannerAdLoaded(this.mAdView, layoutParams);
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdFailedToLoad(LoadAdError loadAdError) {
+        String str;
+        IronSourceError buildLoadFailedError;
+        IronLog ironLog = IronLog.ADAPTER_CALLBACK;
+        ironLog.verbose("adUnitId = " + this.mAdUnitId);
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        if (loadAdError != null) {
+            str = loadAdError.getMessage() + "( " + loadAdError.getCode() + " ) ";
+            if (loadAdError.getCause() != null) {
+                str = str + " Caused by - " + loadAdError.getCause();
+            }
+            if (AdMobAdapter.isNoFillError(loadAdError.getCode())) {
+                buildLoadFailedError = new IronSourceError(606, str);
+            } else {
+                buildLoadFailedError = ErrorBuilder.buildLoadFailedError(str);
+            }
+        } else {
+            str = "Banner failed to load (loadAdError is null)";
+            buildLoadFailedError = ErrorBuilder.buildLoadFailedError("Banner failed to load (loadAdError is null)");
+        }
+        ironLog.error(str + str);
+        this.mListener.onBannerAdLoadFailed(buildLoadFailedError);
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdImpression() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        BannerSmashListener bannerSmashListener = this.mListener;
+        if (bannerSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            bannerSmashListener.onBannerAdShown();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdClicked() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        BannerSmashListener bannerSmashListener = this.mListener;
+        if (bannerSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            bannerSmashListener.onBannerAdClicked();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdOpened() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        BannerSmashListener bannerSmashListener = this.mListener;
+        if (bannerSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            bannerSmashListener.onBannerAdScreenPresented();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdClosed() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        BannerSmashListener bannerSmashListener = this.mListener;
+        if (bannerSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            bannerSmashListener.onBannerAdScreenDismissed();
+        }
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/banner/AdMobBannerAdapter.java

@@ -0,0 +1,292 @@
+package com.ironsource.adapters.admob.banner;
+
+import android.os.Bundle;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.google.android.gms.ads.AdFormat;
+import com.google.android.gms.ads.AdLoader;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.AdSize;
+import com.google.android.gms.ads.AdView;
+import com.google.android.gms.ads.VideoOptions;
+import com.google.android.gms.ads.nativead.NativeAd;
+import com.google.android.gms.ads.nativead.NativeAdOptions;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.environment.ContextProvider;
+import com.ironsource.mediationsdk.AdapterUtils;
+import com.ironsource.mediationsdk.ISBannerSize;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.IronSourceBannerLayout;
+import com.ironsource.mediationsdk.adapter.AbstractBannerAdapter;
+import com.ironsource.mediationsdk.bidding.BiddingDataCallback;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.sdk.BannerSmashListener;
+import com.ironsource.mediationsdk.utils.ErrorBuilder;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class AdMobBannerAdapter extends AbstractBannerAdapter<AdMobAdapter> {
+    private final String IS_NATIVE;
+    private final ConcurrentHashMap<String, AdView> mAdUnitIdToBannerAd;
+    private final ConcurrentHashMap<String, BannerSmashListener> mAdUnitIdToListener;
+    public final ConcurrentHashMap<String, NativeAd> mAdUnitIdToNativeBannerAd;
+
+    public AdMobBannerAdapter(AdMobAdapter adMobAdapter) {
+        super(adMobAdapter);
+        this.IS_NATIVE = "isNative";
+        this.mAdUnitIdToListener = new ConcurrentHashMap<>();
+        this.mAdUnitIdToBannerAd = new ConcurrentHashMap<>();
+        this.mAdUnitIdToNativeBannerAd = new ConcurrentHashMap<>();
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractBannerAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
+    public void initBanners(String str, String str2, @NonNull JSONObject jSONObject, @NonNull BannerSmashListener bannerSmashListener) {
+        initBannersInternal(jSONObject, bannerSmashListener);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractBannerAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
+    public void initBannerForBidding(String str, String str2, @NonNull JSONObject jSONObject, @NonNull BannerSmashListener bannerSmashListener) {
+        initBannersInternal(jSONObject, bannerSmashListener);
+    }
+
+    private void initBannersInternal(@NonNull JSONObject jSONObject, @NonNull BannerSmashListener bannerSmashListener) {
+        String adUnitIdKey = getAdapter().getAdUnitIdKey();
+        String configStringValueFromKey = getConfigStringValueFromKey(jSONObject, adUnitIdKey);
+        if (TextUtils.isEmpty(configStringValueFromKey)) {
+            bannerSmashListener.onBannerInitFailed(ErrorBuilder.buildInitFailedError(getAdUnitIdMissingErrorString(adUnitIdKey), "Banner"));
+            return;
+        }
+        IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+        this.mAdUnitIdToListener.put(configStringValueFromKey, bannerSmashListener);
+        if (getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_SUCCESS) {
+            IronLog.INTERNAL.verbose("onBannerInitSuccess - adUnitId = " + configStringValueFromKey);
+            bannerSmashListener.onBannerInitSuccess();
+            return;
+        }
+        if (getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_FAILED) {
+            IronLog.INTERNAL.verbose("onBannerInitFailed - adUnitId = " + configStringValueFromKey);
+            bannerSmashListener.onBannerInitFailed(ErrorBuilder.buildInitFailedError("AdMob sdk init failed", "Banner"));
+            return;
+        }
+        getAdapter().initSDK(jSONObject);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractAdUnitAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
+    public void onNetworkInitCallbackSuccess() {
+        Iterator<BannerSmashListener> it = this.mAdUnitIdToListener.values().iterator();
+        while (it.hasNext()) {
+            it.next().onBannerInitSuccess();
+        }
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractAdUnitAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
+    public void onNetworkInitCallbackFailed(String str) {
+        Iterator<BannerSmashListener> it = this.mAdUnitIdToListener.values().iterator();
+        while (it.hasNext()) {
+            it.next().onBannerInitFailed(ErrorBuilder.buildInitFailedError(str, "Banner"));
+        }
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractBannerAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
+    public void loadBanner(@NonNull JSONObject jSONObject, JSONObject jSONObject2, @NonNull IronSourceBannerLayout ironSourceBannerLayout, @NonNull BannerSmashListener bannerSmashListener) {
+        loadBannerInternal(jSONObject, jSONObject2, null, ironSourceBannerLayout, bannerSmashListener);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractBannerAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
+    public void loadBannerForBidding(@NonNull JSONObject jSONObject, JSONObject jSONObject2, String str, @NonNull IronSourceBannerLayout ironSourceBannerLayout, @NonNull BannerSmashListener bannerSmashListener) {
+        loadBannerInternal(jSONObject, jSONObject2, str, ironSourceBannerLayout, bannerSmashListener);
+    }
+
+    private void loadBannerInternal(@NonNull final JSONObject jSONObject, final JSONObject jSONObject2, final String str, @NonNull final IronSourceBannerLayout ironSourceBannerLayout, @NonNull final BannerSmashListener bannerSmashListener) {
+        final String configStringValueFromKey = getConfigStringValueFromKey(jSONObject, getAdapter().getAdUnitIdKey());
+        IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+        if (ironSourceBannerLayout == null) {
+            IronLog.INTERNAL.error("banner is null");
+            bannerSmashListener.onBannerAdLoadFailed(ErrorBuilder.buildNoConfigurationAvailableError("banner is null"));
+        } else {
+            final boolean parseBoolean = Boolean.parseBoolean(getConfigStringValueFromKey(jSONObject, "isNative"));
+            postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.banner.AdMobBannerAdapter.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    try {
+                        AdRequest createAdRequest = AdMobBannerAdapter.this.getAdapter().createAdRequest(jSONObject2, str);
+                        if (parseBoolean) {
+                            AdMobBannerAdapter.this.loadNativeBanner(ironSourceBannerLayout, bannerSmashListener, configStringValueFromKey, createAdRequest, jSONObject);
+                            return;
+                        }
+                        AdSize adSize = AdMobBannerAdapter.this.getAdSize(ironSourceBannerLayout.getSize(), AdapterUtils.isLargeScreen(ContextProvider.getInstance().getApplicationContext()));
+                        if (adSize == null) {
+                            bannerSmashListener.onBannerAdLoadFailed(ErrorBuilder.unsupportedBannerSize(AdMobBannerAdapter.this.getAdapter().getProviderName()));
+                            return;
+                        }
+                        AdView adView = new AdView(ContextProvider.getInstance().getApplicationContext());
+                        adView.setAdSize(adSize);
+                        adView.setAdUnitId(configStringValueFromKey);
+                        adView.setAdListener(new AdMobBannerAdListener(bannerSmashListener, configStringValueFromKey, adView));
+                        AdMobBannerAdapter.this.mAdUnitIdToBannerAd.put(configStringValueFromKey, adView);
+                        IronLog.ADAPTER_API.verbose("loadAd");
+                        adView.loadAd(createAdRequest);
+                    } catch (Exception e) {
+                        bannerSmashListener.onBannerAdLoadFailed(ErrorBuilder.buildLoadFailedError("AdMobAdapter loadBanner exception " + e.getMessage()));
+                    }
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void loadNativeBanner(IronSourceBannerLayout ironSourceBannerLayout, BannerSmashListener bannerSmashListener, String str, AdRequest adRequest, JSONObject jSONObject) {
+        if (!isNativeBannerSizeSupported(ironSourceBannerLayout.getSize(), AdapterUtils.isLargeScreen(ContextProvider.getInstance().getApplicationContext()))) {
+            IronLog.INTERNAL.error("size not supported, size = " + ironSourceBannerLayout.getSize().getDescription());
+            bannerSmashListener.onBannerAdLoadFailed(ErrorBuilder.unsupportedBannerSize(getAdapter().getProviderName()));
+            return;
+        }
+        IronLog.ADAPTER_API.verbose("adUnitId = " + str);
+        NativeTemplateType createTemplateType = NativeTemplateType.createTemplateType(jSONObject, ironSourceBannerLayout.getSize());
+        AdMobNativeBannerAdListener adMobNativeBannerAdListener = new AdMobNativeBannerAdListener(this, bannerSmashListener, str, ironSourceBannerLayout.getSize(), createTemplateType);
+        new AdLoader.Builder(ironSourceBannerLayout.getContext(), str).forNativeAd(adMobNativeBannerAdListener).withNativeAdOptions(createNativeAdOptions(createTemplateType)).withAdListener(adMobNativeBannerAdListener).build().loadAd(adRequest);
+    }
+
+    private NativeAdOptions createNativeAdOptions(NativeTemplateType nativeTemplateType) {
+        NativeAdOptions.Builder builder = new NativeAdOptions.Builder();
+        builder.setVideoOptions(new VideoOptions.Builder().setStartMuted(true).build());
+        builder.setAdChoicesPlacement(nativeTemplateType.getAdChoicesPlacement());
+        builder.setMediaAspectRatio(nativeTemplateType.getMediaAspectRatio());
+        return builder.build();
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractBannerAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
+    public void destroyBanner(@NonNull final JSONObject jSONObject) {
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.banner.AdMobBannerAdapter.2
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    AdMobBannerAdapter adMobBannerAdapter = AdMobBannerAdapter.this;
+                    String configStringValueFromKey = adMobBannerAdapter.getConfigStringValueFromKey(jSONObject, adMobBannerAdapter.getAdapter().getAdUnitIdKey());
+                    IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+                    if (AdMobBannerAdapter.this.mAdUnitIdToBannerAd.containsKey(configStringValueFromKey)) {
+                        AdView adView = (AdView) AdMobBannerAdapter.this.mAdUnitIdToBannerAd.get(configStringValueFromKey);
+                        if (adView != null) {
+                            adView.destroy();
+                        }
+                        AdMobBannerAdapter.this.mAdUnitIdToBannerAd.remove(configStringValueFromKey);
+                    }
+                    if (AdMobBannerAdapter.this.mAdUnitIdToNativeBannerAd.containsKey(configStringValueFromKey)) {
+                        NativeAd nativeAd = AdMobBannerAdapter.this.mAdUnitIdToNativeBannerAd.get(configStringValueFromKey);
+                        if (nativeAd != null) {
+                            nativeAd.destroy();
+                        }
+                        AdMobBannerAdapter.this.mAdUnitIdToNativeBannerAd.remove(configStringValueFromKey);
+                    }
+                } catch (Exception e) {
+                    IronLog.ADAPTER_API.error("e = " + e);
+                }
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.sdk.ReleaseMemoryAdapterInterface
+    public void releaseMemory(@NonNull IronSource.AD_UNIT ad_unit, JSONObject jSONObject) {
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.banner.AdMobBannerAdapter.3
+            @Override // java.lang.Runnable
+            public void run() {
+                Iterator it = AdMobBannerAdapter.this.mAdUnitIdToBannerAd.values().iterator();
+                while (it.hasNext()) {
+                    ((AdView) it.next()).destroy();
+                }
+                Iterator<NativeAd> it2 = AdMobBannerAdapter.this.mAdUnitIdToNativeBannerAd.values().iterator();
+                while (it2.hasNext()) {
+                    it2.next().destroy();
+                }
+                AdMobBannerAdapter.this.mAdUnitIdToBannerAd.clear();
+                AdMobBannerAdapter.this.mAdUnitIdToListener.clear();
+                AdMobBannerAdapter.this.mAdUnitIdToNativeBannerAd.clear();
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractBannerAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
+    public void collectBannerBiddingData(@NonNull JSONObject jSONObject, JSONObject jSONObject2, BiddingDataCallback biddingDataCallback) {
+        IronSourceBannerLayout ironSourceBannerLayout;
+        Bundle bundle = new Bundle();
+        if (jSONObject2 != null && (ironSourceBannerLayout = (IronSourceBannerLayout) jSONObject2.opt("bannerLayout")) != null) {
+            ISBannerSize size = ironSourceBannerLayout.getSize();
+            if (size.isAdaptive()) {
+                AdSize adSize = getAdSize(size, AdapterUtils.isLargeScreen(ContextProvider.getInstance().getApplicationContext()));
+                bundle.putInt("adaptive_banner_w", adSize.getWidth());
+                bundle.putInt("adaptive_banner_h", adSize.getHeight());
+                IronLog.ADAPTER_API.verbose("adaptive banner width = " + adSize.getWidth() + ", height = " + adSize.getHeight());
+            }
+        }
+        getAdapter().collectBiddingData(biddingDataCallback, AdFormat.BANNER, bundle);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractBannerAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
+    public int getAdaptiveHeight(int i) {
+        int height = getAdaptiveBannerSize(i).getHeight();
+        IronLog.ADAPTER_API.verbose("height - " + height + " for width - " + i);
+        return height;
+    }
+
+    public AdSize getAdSize(ISBannerSize iSBannerSize, boolean z) {
+        AdSize adSize;
+        String description = iSBannerSize.getDescription();
+        description.hashCode();
+        switch (description) {
+            case "RECTANGLE":
+                adSize = AdSize.MEDIUM_RECTANGLE;
+                break;
+            case "LARGE":
+                adSize = AdSize.LARGE_BANNER;
+                break;
+            case "SMART":
+                if (!z) {
+                    adSize = AdSize.BANNER;
+                    break;
+                } else {
+                    adSize = AdSize.LEADERBOARD;
+                    break;
+                }
+            case "BANNER":
+                adSize = AdSize.BANNER;
+                break;
+            case "CUSTOM":
+                adSize = new AdSize(iSBannerSize.getWidth(), iSBannerSize.getHeight());
+                break;
+            default:
+                adSize = null;
+                break;
+        }
+        try {
+            if (iSBannerSize.isAdaptive() && adSize != null) {
+                AdSize adaptiveBannerSize = getAdaptiveBannerSize(iSBannerSize.containerParams.getWidth());
+                IronLog.INTERNAL.verbose("default height - " + adSize.getHeight() + " adaptive height - " + adaptiveBannerSize.getHeight() + " container height - " + iSBannerSize.containerParams.getHeight() + " default width - " + adSize.getWidth() + " container width - " + iSBannerSize.containerParams.getWidth());
+                return adaptiveBannerSize;
+            }
+        } catch (Exception unused) {
+            IronLog.INTERNAL.error("containerParams is not supported");
+        }
+        return adSize;
+    }
+
+    private static AdSize getAdaptiveBannerSize(int i) {
+        return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(ContextProvider.getInstance().getApplicationContext(), i);
+    }
+
+    private boolean isNativeBannerSizeSupported(ISBannerSize iSBannerSize, boolean z) {
+        String description = iSBannerSize.getDescription();
+        description.hashCode();
+        switch (description) {
+            case "RECTANGLE":
+            case "LARGE":
+            case "BANNER":
+                return true;
+            case "SMART":
+                return !z;
+            default:
+                return false;
+        }
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/banner/AdMobNativeBannerAdListener.java

@@ -0,0 +1,119 @@
+package com.ironsource.adapters.admob.banner;
+
+import com.google.android.gms.ads.AdListener;
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.ads.nativead.NativeAd;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.environment.ContextProvider;
+import com.ironsource.mediationsdk.AbstractAdapter;
+import com.ironsource.mediationsdk.ISBannerSize;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.sdk.BannerSmashListener;
+import com.ironsource.mediationsdk.utils.ErrorBuilder;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes2.dex */
+public class AdMobNativeBannerAdListener extends AdListener implements NativeAd.OnNativeAdLoadedListener {
+    private final String mAdUnitId;
+    private final WeakReference<AdMobBannerAdapter> mBannerAdapter;
+    private final ISBannerSize mBannerSize;
+    private final BannerSmashListener mListener;
+    private final NativeTemplateType mTemplateType;
+
+    public AdMobNativeBannerAdListener(AdMobBannerAdapter adMobBannerAdapter, BannerSmashListener bannerSmashListener, String str, ISBannerSize iSBannerSize, NativeTemplateType nativeTemplateType) {
+        this.mBannerAdapter = new WeakReference<>(adMobBannerAdapter);
+        this.mListener = bannerSmashListener;
+        this.mAdUnitId = str;
+        this.mBannerSize = iSBannerSize;
+        this.mTemplateType = nativeTemplateType;
+    }
+
+    @Override // com.google.android.gms.ads.nativead.NativeAd.OnNativeAdLoadedListener
+    public void onNativeAdLoaded(final NativeAd nativeAd) {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        AbstractAdapter.postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.banner.AdMobNativeBannerAdListener.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (AdMobNativeBannerAdListener.this.mListener != null) {
+                    if (AdMobNativeBannerAdListener.this.mBannerAdapter == null || AdMobNativeBannerAdListener.this.mBannerAdapter.get() == null) {
+                        IronLog.INTERNAL.verbose("adapter is null");
+                        return;
+                    }
+                    AdMobNativeBannerViewHandler adMobNativeBannerViewHandler = new AdMobNativeBannerViewHandler(AdMobNativeBannerAdListener.this.mBannerSize, AdMobNativeBannerAdListener.this.mTemplateType, ContextProvider.getInstance().getApplicationContext());
+                    new AdMobNativeBannerViewBinder().bindView(nativeAd, adMobNativeBannerViewHandler.getNativeAdView(), AdMobNativeBannerAdListener.this.mTemplateType);
+                    ((AdMobBannerAdapter) AdMobNativeBannerAdListener.this.mBannerAdapter.get()).mAdUnitIdToNativeBannerAd.put(AdMobNativeBannerAdListener.this.mAdUnitId, nativeAd);
+                    AdMobNativeBannerAdListener.this.mListener.onBannerAdLoaded(adMobNativeBannerViewHandler.getNativeAdView(), adMobNativeBannerViewHandler.getLayoutParams());
+                    return;
+                }
+                IronLog.INTERNAL.verbose("listener is null");
+            }
+        });
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdFailedToLoad(LoadAdError loadAdError) {
+        IronSourceError buildLoadFailedError;
+        IronLog ironLog = IronLog.ADAPTER_CALLBACK;
+        ironLog.verbose("adUnitId = " + this.mAdUnitId);
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        String str = loadAdError.getMessage() + "( " + loadAdError.getCode() + " ) ";
+        if (loadAdError.getCause() != null) {
+            str = str + " Caused by - " + loadAdError.getCause();
+        }
+        if (AdMobAdapter.isNoFillError(loadAdError.getCode())) {
+            buildLoadFailedError = new IronSourceError(606, str);
+        } else {
+            buildLoadFailedError = ErrorBuilder.buildLoadFailedError(str);
+        }
+        ironLog.error(str + str);
+        this.mListener.onBannerAdLoadFailed(buildLoadFailedError);
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdImpression() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        BannerSmashListener bannerSmashListener = this.mListener;
+        if (bannerSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            bannerSmashListener.onBannerAdShown();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdClicked() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        BannerSmashListener bannerSmashListener = this.mListener;
+        if (bannerSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            bannerSmashListener.onBannerAdClicked();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdOpened() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        BannerSmashListener bannerSmashListener = this.mListener;
+        if (bannerSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            bannerSmashListener.onBannerAdScreenPresented();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdClosed() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        BannerSmashListener bannerSmashListener = this.mListener;
+        if (bannerSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            bannerSmashListener.onBannerAdScreenDismissed();
+        }
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/banner/AdMobNativeBannerViewBinder.java

@@ -0,0 +1,112 @@
+package com.ironsource.adapters.admob.banner;
+
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.TextView;
+import com.google.android.gms.ads.nativead.MediaView;
+import com.google.android.gms.ads.nativead.NativeAd;
+import com.google.android.gms.ads.nativead.NativeAdView;
+import com.ironsource.adapters.admob.R;
+
+/* loaded from: classes2.dex */
+public class AdMobNativeBannerViewBinder {
+    private NativeAdView mAdView;
+    private NativeAd mNativeAd;
+    private NativeTemplateType mTemplateType;
+
+    public void bindView(NativeAd nativeAd, NativeAdView nativeAdView, NativeTemplateType nativeTemplateType) {
+        this.mAdView = nativeAdView;
+        this.mNativeAd = nativeAd;
+        this.mTemplateType = nativeTemplateType;
+        populateView();
+        this.mAdView.setNativeAd(nativeAd);
+    }
+
+    private void populateView() {
+        populateIconView();
+        populateHeadlineView();
+        populateAdvertiserView();
+        populateBodyView();
+        populateMediaView();
+        populateCallToActionView();
+    }
+
+    private void populateIconView() {
+        ImageView imageView = (ImageView) this.mAdView.findViewById(R.id.ad_app_icon);
+        if (imageView != null) {
+            this.mAdView.setIconView(imageView);
+            if (this.mNativeAd.getIcon() != null && this.mNativeAd.getIcon().getDrawable() != null) {
+                imageView.setImageDrawable(this.mNativeAd.getIcon().getDrawable());
+                this.mAdView.getIconView().setVisibility(0);
+            } else {
+                this.mAdView.getIconView().setVisibility(8);
+            }
+        }
+    }
+
+    private void populateHeadlineView() {
+        TextView textView = (TextView) this.mAdView.findViewById(R.id.ad_headline);
+        if (textView != null) {
+            if (this.mNativeAd.getHeadline() != null) {
+                this.mAdView.setHeadlineView(textView);
+                textView.setText(this.mNativeAd.getHeadline());
+                textView.setVisibility(0);
+                return;
+            }
+            textView.setVisibility(8);
+        }
+    }
+
+    private void populateAdvertiserView() {
+        TextView textView = (TextView) this.mAdView.findViewById(R.id.ad_advertiser);
+        if (textView != null) {
+            if (this.mNativeAd.getAdvertiser() != null) {
+                this.mAdView.setAdvertiserView(textView);
+                textView.setText(this.mNativeAd.getAdvertiser());
+                textView.setVisibility(0);
+                return;
+            }
+            textView.setVisibility(8);
+        }
+    }
+
+    private void populateBodyView() {
+        TextView textView = (TextView) this.mAdView.findViewById(R.id.ad_body);
+        if (textView != null) {
+            if (this.mNativeAd.getBody() != null) {
+                this.mAdView.setBodyView(textView);
+                textView.setText(this.mNativeAd.getBody());
+                textView.setVisibility(0);
+                return;
+            }
+            textView.setVisibility(8);
+        }
+    }
+
+    private void populateMediaView() {
+        MediaView mediaView = (MediaView) this.mAdView.findViewById(R.id.ad_media);
+        if (mediaView != null) {
+            if (this.mNativeAd.getMediaContent() != null) {
+                boolean z = this.mNativeAd.getMediaContent().hasVideoContent() && this.mTemplateType.shouldHideVideoContent();
+                this.mAdView.setMediaView(mediaView);
+                mediaView.setMediaContent(this.mNativeAd.getMediaContent());
+                mediaView.setVisibility(z ? 8 : 0);
+                return;
+            }
+            mediaView.setVisibility(8);
+        }
+    }
+
+    private void populateCallToActionView() {
+        Button button = (Button) this.mAdView.findViewById(R.id.ad_call_to_action);
+        if (button != null) {
+            if (this.mNativeAd.getCallToAction() == null || this.mTemplateType.shouldHideCallToAction()) {
+                button.setVisibility(8);
+                return;
+            }
+            this.mAdView.setCallToActionView(button);
+            button.setText(this.mNativeAd.getCallToAction());
+            button.setVisibility(0);
+        }
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/banner/AdMobNativeBannerViewHandler.java

@@ -0,0 +1,45 @@
+package com.ironsource.adapters.admob.banner;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import com.google.android.gms.ads.nativead.NativeAdView;
+import com.ironsource.mediationsdk.AdapterUtils;
+import com.ironsource.mediationsdk.ISBannerSize;
+import com.vungle.ads.internal.protos.Sdk;
+
+/* loaded from: classes2.dex */
+public class AdMobNativeBannerViewHandler {
+    private final NativeAdView mAdView;
+    private FrameLayout.LayoutParams mLayoutParams;
+    private NativeTemplateType mTemplateType;
+
+    public FrameLayout.LayoutParams getLayoutParams() {
+        return this.mLayoutParams;
+    }
+
+    public NativeAdView getNativeAdView() {
+        return this.mAdView;
+    }
+
+    public AdMobNativeBannerViewHandler(ISBannerSize iSBannerSize, NativeTemplateType nativeTemplateType, Context context) {
+        this.mTemplateType = nativeTemplateType;
+        String description = iSBannerSize.getDescription();
+        description.hashCode();
+        switch (description) {
+            case "RECTANGLE":
+                this.mLayoutParams = new FrameLayout.LayoutParams(AdapterUtils.dpToPixels(context, 300), AdapterUtils.dpToPixels(context, 250));
+                break;
+            case "LARGE":
+                this.mLayoutParams = new FrameLayout.LayoutParams(AdapterUtils.dpToPixels(context, Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE), AdapterUtils.dpToPixels(context, 90));
+                break;
+            case "SMART":
+            case "BANNER":
+                this.mLayoutParams = new FrameLayout.LayoutParams(AdapterUtils.dpToPixels(context, Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE), AdapterUtils.dpToPixels(context, 50));
+                break;
+        }
+        this.mLayoutParams.gravity = 17;
+        this.mAdView = (NativeAdView) ((LayoutInflater) context.getSystemService("layout_inflater")).inflate(this.mTemplateType.getLayoutId(), (ViewGroup) null);
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/banner/NativeTemplateType.java

@@ -0,0 +1,69 @@
+package com.ironsource.adapters.admob.banner;
+
+import com.ironsource.adapters.admob.R;
+import com.ironsource.mediationsdk.ISBannerSize;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+enum NativeTemplateType {
+    NB_TMP_BASIC(R.layout.ad_mob_native_banner_template_basic_layout, true, true, 1, 1),
+    NB_TMP_BASIC_LARGE(R.layout.ad_mob_native_banner_template_basic_layout, false, true, 1, 1),
+    NB_TMP_ICON_TEXT(R.layout.ad_mob_native_banner_template_icon_text_layout, true, true, 1, 1),
+    NB_TMP_TEXT_CTA(R.layout.ad_mob_native_banner_template_text_cta_layout, false, true, 3, 1),
+    NB_TMP_RECT(R.layout.ad_mob_native_banner_template_rect_layout, false, false, 1, 1);
+
+    private static final String NATIVE_TEMPLATE_NAME = "nativeBannerTemplateName";
+    private final int mAdChoicesPlacement;
+    private final boolean mHideCallToAction;
+    private final boolean mHideVideoContent;
+    private final int mLayoutId;
+    private final int mMediaAspectRatio;
+
+    public int getAdChoicesPlacement() {
+        return this.mAdChoicesPlacement;
+    }
+
+    public int getLayoutId() {
+        return this.mLayoutId;
+    }
+
+    public int getMediaAspectRatio() {
+        return this.mMediaAspectRatio;
+    }
+
+    public boolean shouldHideCallToAction() {
+        return this.mHideCallToAction;
+    }
+
+    public boolean shouldHideVideoContent() {
+        return this.mHideVideoContent;
+    }
+
+    NativeTemplateType(int i, boolean z, boolean z2, int i2, int i3) {
+        this.mLayoutId = i;
+        this.mHideCallToAction = z;
+        this.mHideVideoContent = z2;
+        this.mAdChoicesPlacement = i2;
+        this.mMediaAspectRatio = i3;
+    }
+
+    public static NativeTemplateType createTemplateType(JSONObject jSONObject, ISBannerSize iSBannerSize) {
+        String description = iSBannerSize.getDescription();
+        description.hashCode();
+        switch (description) {
+            case "RECTANGLE":
+                return NB_TMP_RECT;
+            case "LARGE":
+                return NB_TMP_BASIC_LARGE;
+            case "SMART":
+            case "BANNER":
+                try {
+                    return valueOf(jSONObject.optString(NATIVE_TEMPLATE_NAME, NB_TMP_ICON_TEXT.toString()));
+                } catch (IllegalArgumentException unused) {
+                    return NB_TMP_ICON_TEXT;
+                }
+            default:
+                return NB_TMP_BASIC;
+        }
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/interstitial/AdMobInterstitialAdLoadListener.java

@@ -0,0 +1,60 @@
+package com.ironsource.adapters.admob.interstitial;
+
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.ads.interstitial.InterstitialAd;
+import com.google.android.gms.ads.interstitial.InterstitialAdLoadCallback;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.sdk.InterstitialSmashListener;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes2.dex */
+public class AdMobInterstitialAdLoadListener extends InterstitialAdLoadCallback {
+    private final String mAdUnitId;
+    private final WeakReference<AdMobInterstitialAdapter> mAdapter;
+    private final InterstitialSmashListener mListener;
+
+    public AdMobInterstitialAdLoadListener(AdMobInterstitialAdapter adMobInterstitialAdapter, String str, InterstitialSmashListener interstitialSmashListener) {
+        this.mAdapter = new WeakReference<>(adMobInterstitialAdapter);
+        this.mAdUnitId = str;
+        this.mListener = interstitialSmashListener;
+    }
+
+    @Override // com.google.android.gms.ads.AdLoadCallback
+    public void onAdLoaded(InterstitialAd interstitialAd) {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        WeakReference<AdMobInterstitialAdapter> weakReference = this.mAdapter;
+        if (weakReference == null || weakReference.get() == null) {
+            IronLog.INTERNAL.verbose("adapter is null");
+        } else {
+            this.mAdapter.get().onInterstitialAdLoaded(this.mAdUnitId, interstitialAd);
+            this.mListener.onInterstitialAdReady();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdLoadCallback
+    public void onAdFailedToLoad(LoadAdError loadAdError) {
+        IronLog ironLog = IronLog.ADAPTER_CALLBACK;
+        ironLog.verbose("adUnitId = " + this.mAdUnitId);
+        int code = loadAdError.getCode();
+        String str = loadAdError.getMessage() + "( " + code + " ) ";
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        if (AdMobAdapter.isNoFillError(code)) {
+            code = 1158;
+            str = "No Fill";
+        }
+        if (loadAdError.getCause() != null) {
+            str = str + " Caused by - " + loadAdError.getCause();
+        }
+        ironLog.error("adapterError = " + str);
+        this.mListener.onInterstitialAdLoadFailed(new IronSourceError(code, str));
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/interstitial/AdMobInterstitialAdShowListener.java

@@ -0,0 +1,74 @@
+package com.ironsource.adapters.admob.interstitial;
+
+import com.google.android.gms.ads.AdError;
+import com.google.android.gms.ads.FullScreenContentCallback;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.sdk.InterstitialSmashListener;
+
+/* loaded from: classes2.dex */
+public class AdMobInterstitialAdShowListener extends FullScreenContentCallback {
+    private String mAdUnitId;
+    private InterstitialSmashListener mListener;
+
+    public AdMobInterstitialAdShowListener(String str, InterstitialSmashListener interstitialSmashListener) {
+        this.mListener = interstitialSmashListener;
+        this.mAdUnitId = str;
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdShowedFullScreenContent() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdFailedToShowFullScreenContent(AdError adError) {
+        IronLog ironLog = IronLog.ADAPTER_CALLBACK;
+        ironLog.verbose("adUnitId = " + this.mAdUnitId);
+        int code = adError.getCode();
+        String str = adError.getMessage() + "( " + code + " )";
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        if (adError.getCause() != null) {
+            str = str + " Caused by - " + adError.getCause();
+        }
+        ironLog.error("adapterError = " + str);
+        this.mListener.onInterstitialAdShowFailed(new IronSourceError(code, "onInterstitialAdShowFailed " + this.mAdUnitId + " " + str));
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdImpression() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        InterstitialSmashListener interstitialSmashListener = this.mListener;
+        if (interstitialSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            interstitialSmashListener.onInterstitialAdOpened();
+            this.mListener.onInterstitialAdShowSucceeded();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdClicked() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        InterstitialSmashListener interstitialSmashListener = this.mListener;
+        if (interstitialSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            interstitialSmashListener.onInterstitialAdClicked();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdDismissedFullScreenContent() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        InterstitialSmashListener interstitialSmashListener = this.mListener;
+        if (interstitialSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            interstitialSmashListener.onInterstitialAdClosed();
+        }
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/interstitial/AdMobInterstitialAdapter.java

@@ -0,0 +1,163 @@
+package com.ironsource.adapters.admob.interstitial;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.google.android.gms.ads.AdFormat;
+import com.google.android.gms.ads.interstitial.InterstitialAd;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.environment.ContextProvider;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.adapter.AbstractInterstitialAdapter;
+import com.ironsource.mediationsdk.bidding.BiddingDataCallback;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.sdk.InterstitialSmashListener;
+import com.ironsource.mediationsdk.utils.ErrorBuilder;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class AdMobInterstitialAdapter extends AbstractInterstitialAdapter<AdMobAdapter> {
+    private final ConcurrentHashMap<String, InterstitialAd> mAdUnitIdToAd;
+    private final ConcurrentHashMap<String, Boolean> mAdUnitIdToAdsAvailability;
+    private final ConcurrentHashMap<String, InterstitialSmashListener> mAdUnitIdToListener;
+
+    public AdMobInterstitialAdapter(AdMobAdapter adMobAdapter) {
+        super(adMobAdapter);
+        this.mAdUnitIdToListener = new ConcurrentHashMap<>();
+        this.mAdUnitIdToAd = new ConcurrentHashMap<>();
+        this.mAdUnitIdToAdsAvailability = new ConcurrentHashMap<>();
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractInterstitialAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
+    public void initInterstitial(String str, String str2, @NonNull JSONObject jSONObject, @NonNull InterstitialSmashListener interstitialSmashListener) {
+        initInterstitialInternal(jSONObject, interstitialSmashListener);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractInterstitialAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
+    public void initInterstitialForBidding(String str, String str2, @NonNull JSONObject jSONObject, @NonNull InterstitialSmashListener interstitialSmashListener) {
+        initInterstitialInternal(jSONObject, interstitialSmashListener);
+    }
+
+    private void initInterstitialInternal(@NonNull JSONObject jSONObject, @NonNull InterstitialSmashListener interstitialSmashListener) {
+        String adUnitIdKey = getAdapter().getAdUnitIdKey();
+        String configStringValueFromKey = getConfigStringValueFromKey(jSONObject, adUnitIdKey);
+        if (TextUtils.isEmpty(configStringValueFromKey)) {
+            interstitialSmashListener.onInterstitialInitFailed(ErrorBuilder.buildInitFailedError(getAdUnitIdMissingErrorString(adUnitIdKey), "Interstitial"));
+            return;
+        }
+        IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+        this.mAdUnitIdToListener.put(configStringValueFromKey, interstitialSmashListener);
+        if (getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_SUCCESS) {
+            IronLog.INTERNAL.verbose("onInterstitialInitSuccess - adUnitId = " + configStringValueFromKey);
+            interstitialSmashListener.onInterstitialInitSuccess();
+            return;
+        }
+        if (getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_FAILED) {
+            IronLog.INTERNAL.verbose("onInterstitialInitFailed - adUnitId = " + configStringValueFromKey);
+            interstitialSmashListener.onInterstitialInitFailed(ErrorBuilder.buildInitFailedError("AdMob sdk init failed", "Interstitial"));
+            return;
+        }
+        getAdapter().initSDK(jSONObject);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractAdUnitAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
+    public void onNetworkInitCallbackSuccess() {
+        Iterator<InterstitialSmashListener> it = this.mAdUnitIdToListener.values().iterator();
+        while (it.hasNext()) {
+            it.next().onInterstitialInitSuccess();
+        }
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractAdUnitAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
+    public void onNetworkInitCallbackFailed(String str) {
+        Iterator<InterstitialSmashListener> it = this.mAdUnitIdToListener.values().iterator();
+        while (it.hasNext()) {
+            it.next().onInterstitialInitFailed(ErrorBuilder.buildInitFailedError(str, "Interstitial"));
+        }
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractInterstitialAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
+    public void loadInterstitial(@NonNull JSONObject jSONObject, JSONObject jSONObject2, @NonNull InterstitialSmashListener interstitialSmashListener) {
+        loadInterstitialInternal(jSONObject, jSONObject2, null, interstitialSmashListener);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractInterstitialAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
+    public void loadInterstitialForBidding(@NonNull JSONObject jSONObject, JSONObject jSONObject2, String str, @NonNull InterstitialSmashListener interstitialSmashListener) {
+        loadInterstitialInternal(jSONObject, jSONObject2, str, interstitialSmashListener);
+    }
+
+    private void loadInterstitialInternal(@NonNull final JSONObject jSONObject, final JSONObject jSONObject2, final String str, @NonNull final InterstitialSmashListener interstitialSmashListener) {
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.interstitial.AdMobInterstitialAdapter.1
+            @Override // java.lang.Runnable
+            public void run() {
+                AdMobInterstitialAdapter adMobInterstitialAdapter = AdMobInterstitialAdapter.this;
+                String configStringValueFromKey = adMobInterstitialAdapter.getConfigStringValueFromKey(jSONObject, adMobInterstitialAdapter.getAdapter().getAdUnitIdKey());
+                IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+                AdMobInterstitialAdapter.this.mAdUnitIdToAdsAvailability.put(configStringValueFromKey, Boolean.FALSE);
+                InterstitialAd.load(ContextProvider.getInstance().getApplicationContext(), configStringValueFromKey, AdMobInterstitialAdapter.this.getAdapter().createAdRequest(jSONObject2, str), new AdMobInterstitialAdLoadListener(AdMobInterstitialAdapter.this, configStringValueFromKey, interstitialSmashListener));
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractInterstitialAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
+    public void showInterstitial(@NonNull final JSONObject jSONObject, @NonNull final InterstitialSmashListener interstitialSmashListener) {
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.interstitial.AdMobInterstitialAdapter.2
+            @Override // java.lang.Runnable
+            public void run() {
+                AdMobInterstitialAdapter adMobInterstitialAdapter = AdMobInterstitialAdapter.this;
+                String configStringValueFromKey = adMobInterstitialAdapter.getConfigStringValueFromKey(jSONObject, adMobInterstitialAdapter.getAdapter().getAdUnitIdKey());
+                IronLog ironLog = IronLog.ADAPTER_API;
+                ironLog.verbose("adUnitId = " + configStringValueFromKey);
+                InterstitialAd interstitialAd = AdMobInterstitialAdapter.this.getInterstitialAd(configStringValueFromKey);
+                if (AdMobInterstitialAdapter.this.isInterstitialReadyForAdUnitId(configStringValueFromKey) && interstitialAd != null) {
+                    interstitialAd.setFullScreenContentCallback(new AdMobInterstitialAdShowListener(configStringValueFromKey, interstitialSmashListener));
+                    interstitialAd.show(ContextProvider.getInstance().getCurrentActiveActivity());
+                } else {
+                    ironLog.error("Ad not ready to display");
+                    interstitialSmashListener.onInterstitialAdShowFailed(ErrorBuilder.buildNoAdsToShowError("Interstitial"));
+                }
+                AdMobInterstitialAdapter.this.mAdUnitIdToAdsAvailability.put(configStringValueFromKey, Boolean.FALSE);
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractInterstitialAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
+    public final boolean isInterstitialReady(@NonNull JSONObject jSONObject) {
+        return isInterstitialReadyForAdUnitId(getConfigStringValueFromKey(jSONObject, getAdapter().getAdUnitIdKey()));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public boolean isInterstitialReadyForAdUnitId(String str) {
+        return !TextUtils.isEmpty(str) && this.mAdUnitIdToAdsAvailability.containsKey(str) && this.mAdUnitIdToAdsAvailability.get(str).booleanValue();
+    }
+
+    @Override // com.ironsource.mediationsdk.sdk.ReleaseMemoryAdapterInterface
+    public void releaseMemory(@NonNull IronSource.AD_UNIT ad_unit, JSONObject jSONObject) {
+        Iterator<InterstitialAd> it = this.mAdUnitIdToAd.values().iterator();
+        while (it.hasNext()) {
+            it.next().setFullScreenContentCallback(null);
+        }
+        this.mAdUnitIdToAd.clear();
+        this.mAdUnitIdToListener.clear();
+        this.mAdUnitIdToAdsAvailability.clear();
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractInterstitialAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
+    public void collectInterstitialBiddingData(@NonNull JSONObject jSONObject, JSONObject jSONObject2, BiddingDataCallback biddingDataCallback) {
+        getAdapter().collectBiddingData(biddingDataCallback, AdFormat.INTERSTITIAL, null);
+    }
+
+    public void onInterstitialAdLoaded(String str, InterstitialAd interstitialAd) {
+        this.mAdUnitIdToAd.put(str, interstitialAd);
+        this.mAdUnitIdToAdsAvailability.put(str, Boolean.TRUE);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public InterstitialAd getInterstitialAd(String str) {
+        if (TextUtils.isEmpty(str) || !this.mAdUnitIdToAd.containsKey(str)) {
+            return null;
+        }
+        return this.mAdUnitIdToAd.get(str);
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/nativead/AdMobNativeAdAdapter.java

@@ -0,0 +1,181 @@
+package com.ironsource.adapters.admob.nativead;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.google.android.gms.ads.AdFormat;
+import com.google.android.gms.ads.AdLoader;
+import com.google.android.gms.ads.nativead.NativeAd;
+import com.google.android.gms.ads.nativead.NativeAdOptions;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.environment.ContextProvider;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.adapter.AbstractNativeAdAdapter;
+import com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdSmashListener;
+import com.ironsource.mediationsdk.adunit.adapter.utility.AdOptionsPosition;
+import com.ironsource.mediationsdk.adunit.adapter.utility.NativeAdProperties;
+import com.ironsource.mediationsdk.bidding.BiddingDataCallback;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.utils.ErrorBuilder;
+import com.ironsource.mediationsdk.utils.IronSourceConstants;
+import java.lang.ref.WeakReference;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class AdMobNativeAdAdapter extends AbstractNativeAdAdapter<AdMobAdapter> {
+    protected WeakReference<NativeAd> mAd;
+    private NativeAdSmashListener mSmashListener;
+
+    @Override // com.ironsource.mediationsdk.sdk.ReleaseMemoryAdapterInterface
+    public void releaseMemory(@NonNull IronSource.AD_UNIT ad_unit, JSONObject jSONObject) {
+    }
+
+    public AdMobNativeAdAdapter(AdMobAdapter adMobAdapter) {
+        super(adMobAdapter);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractNativeAdAdapter, com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdAdapterInterface
+    public void initNativeAds(String str, String str2, @NonNull JSONObject jSONObject, @NonNull NativeAdSmashListener nativeAdSmashListener) {
+        initNativeAdsInternal(jSONObject, nativeAdSmashListener);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractNativeAdAdapter, com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdAdapterInterface
+    public void initNativeAdForBidding(String str, String str2, @NonNull JSONObject jSONObject, @NonNull NativeAdSmashListener nativeAdSmashListener) {
+        initNativeAdsInternal(jSONObject, nativeAdSmashListener);
+    }
+
+    public void initNativeAdsInternal(@NonNull final JSONObject jSONObject, @NonNull final NativeAdSmashListener nativeAdSmashListener) {
+        String adUnitIdKey = getAdapter().getAdUnitIdKey();
+        final String configStringValueFromKey = getConfigStringValueFromKey(jSONObject, adUnitIdKey);
+        if (TextUtils.isEmpty(configStringValueFromKey)) {
+            nativeAdSmashListener.onNativeAdInitFailed(ErrorBuilder.buildInitFailedError(getAdUnitIdMissingErrorString(adUnitIdKey), IronSourceConstants.NATIVE_AD_UNIT));
+            return;
+        }
+        IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+        this.mSmashListener = nativeAdSmashListener;
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.nativead.AdMobNativeAdAdapter.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (AdMobNativeAdAdapter.this.getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_SUCCESS) {
+                    IronLog.INTERNAL.verbose("onNativeAdInitSuccess - adUnitId = " + configStringValueFromKey);
+                    nativeAdSmashListener.onNativeAdInitSuccess();
+                    return;
+                }
+                if (AdMobNativeAdAdapter.this.getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_FAILED) {
+                    IronLog.INTERNAL.verbose("onNativeAdInitFailed - adUnitId = " + configStringValueFromKey);
+                    nativeAdSmashListener.onNativeAdInitFailed(ErrorBuilder.buildInitFailedError("AdMob sdk init failed", IronSourceConstants.NATIVE_AD_UNIT));
+                    return;
+                }
+                AdMobNativeAdAdapter.this.getAdapter().initSDK(jSONObject);
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractAdUnitAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
+    public void onNetworkInitCallbackSuccess() {
+        NativeAdSmashListener nativeAdSmashListener = this.mSmashListener;
+        if (nativeAdSmashListener != null) {
+            nativeAdSmashListener.onNativeAdInitSuccess();
+        }
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractAdUnitAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
+    public void onNetworkInitCallbackFailed(String str) {
+        NativeAdSmashListener nativeAdSmashListener = this.mSmashListener;
+        if (nativeAdSmashListener != null) {
+            nativeAdSmashListener.onNativeAdInitFailed(ErrorBuilder.buildInitFailedError(str, IronSourceConstants.NATIVE_AD_UNIT));
+        }
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractNativeAdAdapter, com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdAdapterInterface
+    public void loadNativeAd(@NonNull JSONObject jSONObject, JSONObject jSONObject2, @NonNull NativeAdSmashListener nativeAdSmashListener) {
+        loadNativeAdInternal(jSONObject, jSONObject2, null, nativeAdSmashListener);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractNativeAdAdapter, com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdAdapterInterface
+    public void loadNativeAdForBidding(@NonNull JSONObject jSONObject, JSONObject jSONObject2, String str, @NonNull NativeAdSmashListener nativeAdSmashListener) {
+        loadNativeAdInternal(jSONObject, jSONObject2, str, nativeAdSmashListener);
+    }
+
+    public void loadNativeAdInternal(@NonNull JSONObject jSONObject, final JSONObject jSONObject2, final String str, @NonNull final NativeAdSmashListener nativeAdSmashListener) {
+        final String configStringValueFromKey = getConfigStringValueFromKey(jSONObject, getAdapter().getAdUnitIdKey());
+        IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+        final NativeAdProperties nativeAdProperties = getNativeAdProperties(jSONObject);
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.nativead.AdMobNativeAdAdapter.2
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    AdOptionsPosition adOptionsPosition = nativeAdProperties.getAdOptionsPosition();
+                    AdMobNativeAdListener adMobNativeAdListener = new AdMobNativeAdListener(AdMobNativeAdAdapter.this, configStringValueFromKey, nativeAdSmashListener);
+                    new AdLoader.Builder(ContextProvider.getInstance().getApplicationContext(), configStringValueFromKey).forNativeAd(adMobNativeAdListener).withAdListener(adMobNativeAdListener).withNativeAdOptions(new NativeAdOptions.Builder().setAdChoicesPlacement(AdMobNativeAdAdapter.this.getAdChoicesPosition(adOptionsPosition)).build()).build().loadAd(AdMobNativeAdAdapter.this.getAdapter().createAdRequest(jSONObject2, str));
+                } catch (Exception e) {
+                    nativeAdSmashListener.onNativeAdLoadFailed(ErrorBuilder.buildLoadFailedError("AdMobAdapter loadNativeAd exception " + e.getMessage()));
+                }
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractNativeAdAdapter, com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdAdapterInterface
+    public void destroyNativeAd(@NonNull JSONObject jSONObject) {
+        final String configStringValueFromKey = getConfigStringValueFromKey(jSONObject, getAdapter().getAdUnitIdKey());
+        IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.nativead.AdMobNativeAdAdapter.3
+            @Override // java.lang.Runnable
+            public void run() {
+                WeakReference<NativeAd> weakReference = AdMobNativeAdAdapter.this.mAd;
+                if (weakReference == null || weakReference.get() == null) {
+                    return;
+                }
+                try {
+                    AdMobNativeAdAdapter.this.mSmashListener = null;
+                    AdMobNativeAdAdapter.this.mAd.get().destroy();
+                    AdMobNativeAdAdapter.this.mAd = null;
+                } catch (Exception e) {
+                    IronLog.INTERNAL.error("destroyNativeAd failed for adUnitId - " + configStringValueFromKey + " with an exception = " + e);
+                }
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractNativeAdAdapter, com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdAdapterInterface
+    public void collectNativeAdBiddingData(@NonNull JSONObject jSONObject, JSONObject jSONObject2, @NonNull BiddingDataCallback biddingDataCallback) {
+        getAdapter().collectBiddingData(biddingDataCallback, AdFormat.NATIVE, null);
+    }
+
+    /* renamed from: com.ironsource.adapters.admob.nativead.AdMobNativeAdAdapter$4, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass4 {
+        static final /* synthetic */ int[] $SwitchMap$com$ironsource$mediationsdk$adunit$adapter$utility$AdOptionsPosition;
+
+        static {
+            int[] iArr = new int[AdOptionsPosition.values().length];
+            $SwitchMap$com$ironsource$mediationsdk$adunit$adapter$utility$AdOptionsPosition = iArr;
+            try {
+                iArr[AdOptionsPosition.TOP_LEFT.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$com$ironsource$mediationsdk$adunit$adapter$utility$AdOptionsPosition[AdOptionsPosition.TOP_RIGHT.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                $SwitchMap$com$ironsource$mediationsdk$adunit$adapter$utility$AdOptionsPosition[AdOptionsPosition.BOTTOM_LEFT.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                $SwitchMap$com$ironsource$mediationsdk$adunit$adapter$utility$AdOptionsPosition[AdOptionsPosition.BOTTOM_RIGHT.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public int getAdChoicesPosition(AdOptionsPosition adOptionsPosition) {
+        int i = AnonymousClass4.$SwitchMap$com$ironsource$mediationsdk$adunit$adapter$utility$AdOptionsPosition[adOptionsPosition.ordinal()];
+        if (i == 1) {
+            return 0;
+        }
+        if (i != 2) {
+            return i != 4 ? 3 : 2;
+        }
+        return 1;
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/nativead/AdMobNativeAdData.java

@@ -0,0 +1,49 @@
+package com.ironsource.adapters.admob.nativead;
+
+import com.google.android.gms.ads.nativead.NativeAd;
+import com.ironsource.mediationsdk.ads.nativead.AdapterNativeAdData;
+import com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdDataInterface;
+import com.ironsource.mediationsdk.logger.IronLog;
+
+/* loaded from: classes2.dex */
+public class AdMobNativeAdData extends AdapterNativeAdData {
+    private NativeAd mNativeAd;
+
+    public AdMobNativeAdData(NativeAd nativeAd) {
+        this.mNativeAd = nativeAd;
+    }
+
+    @Override // com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdDataInterface
+    public String getTitle() {
+        IronLog.ADAPTER_CALLBACK.verbose("headline = " + this.mNativeAd.getHeadline());
+        return this.mNativeAd.getHeadline();
+    }
+
+    @Override // com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdDataInterface
+    public String getAdvertiser() {
+        IronLog.ADAPTER_CALLBACK.verbose("advertiser = " + this.mNativeAd.getAdvertiser());
+        return this.mNativeAd.getAdvertiser();
+    }
+
+    @Override // com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdDataInterface
+    public String getBody() {
+        IronLog.ADAPTER_CALLBACK.verbose("body = " + this.mNativeAd.getBody());
+        return this.mNativeAd.getBody();
+    }
+
+    @Override // com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdDataInterface
+    public String getCallToAction() {
+        IronLog.ADAPTER_CALLBACK.verbose("cta = " + this.mNativeAd.getCallToAction());
+        return this.mNativeAd.getCallToAction();
+    }
+
+    @Override // com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdDataInterface
+    public NativeAdDataInterface.Image getIcon() {
+        NativeAd.Image icon = this.mNativeAd.getIcon();
+        if (icon == null) {
+            return null;
+        }
+        IronLog.ADAPTER_CALLBACK.verbose("icon uri = " + icon.getUri());
+        return new NativeAdDataInterface.Image(icon.getDrawable(), icon.getUri());
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/nativead/AdMobNativeAdListener.java

@@ -0,0 +1,99 @@
+package com.ironsource.adapters.admob.nativead;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.ads.AdListener;
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.ads.nativead.NativeAd;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.mediationsdk.ads.nativead.interfaces.NativeAdSmashListener;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.utils.ErrorBuilder;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes2.dex */
+public class AdMobNativeAdListener extends AdListener implements NativeAd.OnNativeAdLoadedListener {
+    private final String mAdUnitId;
+    private final WeakReference<AdMobNativeAdAdapter> mAdapter;
+    private final NativeAdSmashListener mListener;
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdLoaded() {
+    }
+
+    public AdMobNativeAdListener(AdMobNativeAdAdapter adMobNativeAdAdapter, String str, NativeAdSmashListener nativeAdSmashListener) {
+        this.mAdapter = new WeakReference<>(adMobNativeAdAdapter);
+        this.mAdUnitId = str;
+        this.mListener = nativeAdSmashListener;
+    }
+
+    @Override // com.google.android.gms.ads.nativead.NativeAd.OnNativeAdLoadedListener
+    public void onNativeAdLoaded(@NonNull NativeAd nativeAd) {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        WeakReference<AdMobNativeAdAdapter> weakReference = this.mAdapter;
+        if (weakReference == null || weakReference.get() == null) {
+            IronLog.INTERNAL.verbose("adapter is null");
+            return;
+        }
+        this.mAdapter.get().mAd = new WeakReference<>(nativeAd);
+        this.mListener.onNativeAdLoaded(new AdMobNativeAdData(nativeAd), new AdMobNativeAdViewBinder(nativeAd));
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+        IronSourceError buildLoadFailedError;
+        IronLog ironLog = IronLog.ADAPTER_CALLBACK;
+        ironLog.verbose("adUnitId = " + this.mAdUnitId);
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        String str = loadAdError.getMessage() + "( " + loadAdError.getCode() + " ) ";
+        if (loadAdError.getCause() != null) {
+            str = str + " Caused by - " + loadAdError.getCause();
+        }
+        ironLog.error("adapterError = " + str);
+        if (AdMobAdapter.isNoFillError(loadAdError.getCode())) {
+            buildLoadFailedError = new IronSourceError(IronSourceError.ERROR_NT_LOAD_NO_FILL, str);
+        } else {
+            buildLoadFailedError = ErrorBuilder.buildLoadFailedError(str);
+        }
+        this.mListener.onNativeAdLoadFailed(buildLoadFailedError);
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdOpened() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdImpression() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        NativeAdSmashListener nativeAdSmashListener = this.mListener;
+        if (nativeAdSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            nativeAdSmashListener.onNativeAdShown();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdClicked() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        NativeAdSmashListener nativeAdSmashListener = this.mListener;
+        if (nativeAdSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            nativeAdSmashListener.onNativeAdClicked();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdListener
+    public void onAdClosed() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/nativead/AdMobNativeAdViewBinder.java

@@ -0,0 +1,49 @@
+package com.ironsource.adapters.admob.nativead;
+
+import android.view.View;
+import android.view.ViewGroup;
+import com.google.android.gms.ads.nativead.MediaView;
+import com.google.android.gms.ads.nativead.NativeAd;
+import com.google.android.gms.ads.nativead.NativeAdView;
+import com.ironsource.mediationsdk.ads.nativead.LevelPlayMediaView;
+import com.ironsource.mediationsdk.ads.nativead.internal.NativeAdViewHolder;
+import com.ironsource.mediationsdk.adunit.adapter.internal.nativead.AdapterNativeAdViewBinder;
+import com.ironsource.mediationsdk.logger.IronLog;
+
+/* loaded from: classes2.dex */
+public class AdMobNativeAdViewBinder extends AdapterNativeAdViewBinder {
+    private final NativeAd mNativeAd;
+    private NativeAdView mNativeAdView;
+
+    @Override // com.ironsource.mediationsdk.adunit.adapter.internal.nativead.AdapterNativeAdViewBinderInterface
+    public ViewGroup getNetworkNativeAdView() {
+        return this.mNativeAdView;
+    }
+
+    public AdMobNativeAdViewBinder(NativeAd nativeAd) {
+        this.mNativeAd = nativeAd;
+    }
+
+    @Override // com.ironsource.mediationsdk.adunit.adapter.internal.nativead.AdapterNativeAdViewBinderInterface
+    public void setNativeAdView(View view) {
+        if (view == null) {
+            IronLog.INTERNAL.error("nativeAdView is null");
+            return;
+        }
+        this.mNativeAdView = new NativeAdView(view.getContext());
+        NativeAdViewHolder nativeAdViewHolder = getNativeAdViewHolder();
+        this.mNativeAdView.setHeadlineView(nativeAdViewHolder.getTitleView());
+        this.mNativeAdView.setAdvertiserView(nativeAdViewHolder.getAdvertiserView());
+        this.mNativeAdView.setIconView(nativeAdViewHolder.getIconView());
+        this.mNativeAdView.setBodyView(nativeAdViewHolder.getBodyView());
+        LevelPlayMediaView mediaView = nativeAdViewHolder.getMediaView();
+        if (mediaView != null) {
+            MediaView mediaView2 = new MediaView(mediaView.getContext());
+            mediaView.addView(mediaView2);
+            this.mNativeAdView.setMediaView(mediaView2);
+        }
+        this.mNativeAdView.setCallToActionView(nativeAdViewHolder.getCallToActionView());
+        this.mNativeAdView.addView(view);
+        this.mNativeAdView.setNativeAd(this.mNativeAd);
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/rewardedvideo/AdMobRewardedVideoAdLoadListener.java

@@ -0,0 +1,62 @@
+package com.ironsource.adapters.admob.rewardedvideo;
+
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.ads.rewarded.RewardedAd;
+import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.sdk.RewardedVideoSmashListener;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes2.dex */
+public class AdMobRewardedVideoAdLoadListener extends RewardedAdLoadCallback {
+    private String mAdUnitId;
+    private RewardedVideoSmashListener mListener;
+    private WeakReference<AdMobRewardedVideoAdapter> mRewardedVideoAdapter;
+
+    public AdMobRewardedVideoAdLoadListener(AdMobRewardedVideoAdapter adMobRewardedVideoAdapter, String str, RewardedVideoSmashListener rewardedVideoSmashListener) {
+        this.mRewardedVideoAdapter = new WeakReference<>(adMobRewardedVideoAdapter);
+        this.mAdUnitId = str;
+        this.mListener = rewardedVideoSmashListener;
+    }
+
+    @Override // com.google.android.gms.ads.AdLoadCallback
+    public void onAdLoaded(RewardedAd rewardedAd) {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        WeakReference<AdMobRewardedVideoAdapter> weakReference = this.mRewardedVideoAdapter;
+        if (weakReference == null || weakReference.get() == null) {
+            IronLog.INTERNAL.verbose("adapter is null");
+        } else {
+            this.mRewardedVideoAdapter.get().onRewardedVideoAdLoaded(this.mAdUnitId, rewardedAd);
+            this.mListener.onRewardedVideoAvailabilityChanged(true);
+        }
+    }
+
+    @Override // com.google.android.gms.ads.AdLoadCallback
+    public void onAdFailedToLoad(LoadAdError loadAdError) {
+        IronLog ironLog = IronLog.ADAPTER_CALLBACK;
+        ironLog.verbose("adUnitId = " + this.mAdUnitId);
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        int code = loadAdError.getCode();
+        String str = loadAdError.getMessage() + "( " + code + " )";
+        ironLog.error("adapterError = " + str);
+        if (AdMobAdapter.isNoFillError(code)) {
+            code = 1058;
+            str = "No Fill";
+        }
+        if (loadAdError.getCause() != null) {
+            str = str + "Caused by " + loadAdError.getCause();
+        }
+        ironLog.error("adapterError = " + str);
+        this.mListener.onRewardedVideoAvailabilityChanged(false);
+        this.mListener.onRewardedVideoLoadFailed(new IronSourceError(code, str));
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/rewardedvideo/AdMobRewardedVideoAdShowListener.java

@@ -0,0 +1,86 @@
+package com.ironsource.adapters.admob.rewardedvideo;
+
+import com.google.android.gms.ads.AdError;
+import com.google.android.gms.ads.FullScreenContentCallback;
+import com.google.android.gms.ads.OnUserEarnedRewardListener;
+import com.google.android.gms.ads.rewarded.RewardItem;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.mediationsdk.sdk.RewardedVideoSmashListener;
+
+/* loaded from: classes2.dex */
+public class AdMobRewardedVideoAdShowListener extends FullScreenContentCallback implements OnUserEarnedRewardListener {
+    private String mAdUnitId;
+    private RewardedVideoSmashListener mListener;
+
+    public AdMobRewardedVideoAdShowListener(String str, RewardedVideoSmashListener rewardedVideoSmashListener) {
+        this.mListener = rewardedVideoSmashListener;
+        this.mAdUnitId = str;
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdShowedFullScreenContent() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdFailedToShowFullScreenContent(AdError adError) {
+        IronLog ironLog = IronLog.ADAPTER_CALLBACK;
+        ironLog.verbose("adUnitId = " + this.mAdUnitId);
+        int code = adError.getCode();
+        String str = adError.getMessage() + "( " + code + " )";
+        if (this.mListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+            return;
+        }
+        if (adError.getCause() != null) {
+            str = str + " Caused by - " + adError.getCause();
+        }
+        ironLog.error("adapterError = " + str);
+        this.mListener.onRewardedVideoAdShowFailed(new IronSourceError(code, "onRewardedAdFailedToShow " + this.mAdUnitId + " " + str));
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdImpression() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        RewardedVideoSmashListener rewardedVideoSmashListener = this.mListener;
+        if (rewardedVideoSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            rewardedVideoSmashListener.onRewardedVideoAdOpened();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdClicked() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        RewardedVideoSmashListener rewardedVideoSmashListener = this.mListener;
+        if (rewardedVideoSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            rewardedVideoSmashListener.onRewardedVideoAdClicked();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.OnUserEarnedRewardListener
+    public void onUserEarnedReward(RewardItem rewardItem) {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        RewardedVideoSmashListener rewardedVideoSmashListener = this.mListener;
+        if (rewardedVideoSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            rewardedVideoSmashListener.onRewardedVideoAdRewarded();
+        }
+    }
+
+    @Override // com.google.android.gms.ads.FullScreenContentCallback
+    public void onAdDismissedFullScreenContent() {
+        IronLog.ADAPTER_CALLBACK.verbose("adUnitId = " + this.mAdUnitId);
+        RewardedVideoSmashListener rewardedVideoSmashListener = this.mListener;
+        if (rewardedVideoSmashListener == null) {
+            IronLog.INTERNAL.verbose("listener is null");
+        } else {
+            rewardedVideoSmashListener.onRewardedVideoAdClosed();
+        }
+    }
+}

decompiled/sources/com/ironsource/adapters/admob/rewardedvideo/AdMobRewardedVideoAdapter.java

@@ -0,0 +1,195 @@
+package com.ironsource.adapters.admob.rewardedvideo;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.google.android.gms.ads.AdFormat;
+import com.google.android.gms.ads.rewarded.RewardedAd;
+import com.ironsource.adapters.admob.AdMobAdapter;
+import com.ironsource.environment.ContextProvider;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.adapter.AbstractRewardedVideoAdapter;
+import com.ironsource.mediationsdk.bidding.BiddingDataCallback;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.sdk.RewardedVideoSmashListener;
+import com.ironsource.mediationsdk.utils.ErrorBuilder;
+import com.ironsource.mediationsdk.utils.IronSourceConstants;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class AdMobRewardedVideoAdapter extends AbstractRewardedVideoAdapter<AdMobAdapter> {
+    private final ConcurrentHashMap<String, RewardedAd> mAdUnitIdToAd;
+    private final ConcurrentHashMap<String, JSONObject> mAdUnitIdToAdData;
+    private final ConcurrentHashMap<String, Boolean> mAdUnitIdToAdsAvailability;
+    private final ConcurrentHashMap<String, RewardedVideoSmashListener> mAdUnitIdToListener;
+    private final CopyOnWriteArraySet<String> mAdUnitIdsForInitCallbacks;
+
+    public AdMobRewardedVideoAdapter(AdMobAdapter adMobAdapter) {
+        super(adMobAdapter);
+        this.mAdUnitIdToListener = new ConcurrentHashMap<>();
+        this.mAdUnitIdToAdData = new ConcurrentHashMap<>();
+        this.mAdUnitIdToAd = new ConcurrentHashMap<>();
+        this.mAdUnitIdToAdsAvailability = new ConcurrentHashMap<>();
+        this.mAdUnitIdsForInitCallbacks = new CopyOnWriteArraySet<>();
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractRewardedVideoAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
+    public void initAndLoadRewardedVideo(String str, String str2, @NonNull JSONObject jSONObject, JSONObject jSONObject2, @NonNull RewardedVideoSmashListener rewardedVideoSmashListener) {
+        String adUnitIdKey = getAdapter().getAdUnitIdKey();
+        String configStringValueFromKey = getConfigStringValueFromKey(jSONObject, adUnitIdKey);
+        if (TextUtils.isEmpty(configStringValueFromKey)) {
+            IronLog.INTERNAL.error(getAdUnitIdMissingErrorString(adUnitIdKey));
+            rewardedVideoSmashListener.onRewardedVideoAvailabilityChanged(false);
+            return;
+        }
+        IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+        this.mAdUnitIdToListener.put(configStringValueFromKey, rewardedVideoSmashListener);
+        if (getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_SUCCESS) {
+            loadRewardedVideoAdInternal(configStringValueFromKey, jSONObject2, null, rewardedVideoSmashListener);
+            return;
+        }
+        if (getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_FAILED) {
+            IronLog.INTERNAL.verbose("onRewardedVideoAvailabilityChanged(false) - adUnitId = " + configStringValueFromKey);
+            rewardedVideoSmashListener.onRewardedVideoAvailabilityChanged(false);
+            return;
+        }
+        if (jSONObject2 != null) {
+            this.mAdUnitIdToAdData.put(configStringValueFromKey, jSONObject2);
+        }
+        getAdapter().initSDK(jSONObject);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractRewardedVideoAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
+    public void initRewardedVideoWithCallback(String str, String str2, @NonNull JSONObject jSONObject, @NonNull RewardedVideoSmashListener rewardedVideoSmashListener) {
+        String adUnitIdKey = getAdapter().getAdUnitIdKey();
+        String configStringValueFromKey = getConfigStringValueFromKey(jSONObject, adUnitIdKey);
+        if (TextUtils.isEmpty(configStringValueFromKey)) {
+            IronLog.INTERNAL.error(getAdUnitIdMissingErrorString(adUnitIdKey));
+            rewardedVideoSmashListener.onRewardedVideoInitFailed(ErrorBuilder.buildInitFailedError(getAdUnitIdMissingErrorString(adUnitIdKey), IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
+            return;
+        }
+        IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+        this.mAdUnitIdToListener.put(configStringValueFromKey, rewardedVideoSmashListener);
+        this.mAdUnitIdsForInitCallbacks.add(configStringValueFromKey);
+        if (getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_SUCCESS) {
+            IronLog.INTERNAL.verbose("onRewardedVideoInitSuccess - adUnitId = " + configStringValueFromKey);
+            rewardedVideoSmashListener.onRewardedVideoInitSuccess();
+            return;
+        }
+        if (getAdapter().getInitState() == AdMobAdapter.InitState.INIT_STATE_FAILED) {
+            IronLog.INTERNAL.verbose("init failed - adUnitId = " + configStringValueFromKey);
+            rewardedVideoSmashListener.onRewardedVideoInitFailed(ErrorBuilder.buildInitFailedError("AdMob sdk init failed", IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
+            return;
+        }
+        getAdapter().initSDK(jSONObject);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractAdUnitAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
+    public void onNetworkInitCallbackSuccess() {
+        for (String str : this.mAdUnitIdToListener.keySet()) {
+            RewardedVideoSmashListener rewardedVideoSmashListener = this.mAdUnitIdToListener.get(str);
+            if (this.mAdUnitIdsForInitCallbacks.contains(str)) {
+                rewardedVideoSmashListener.onRewardedVideoInitSuccess();
+            } else {
+                loadRewardedVideoAdInternal(str, this.mAdUnitIdToAdData.get(str), null, rewardedVideoSmashListener);
+            }
+        }
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractAdUnitAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
+    public void onNetworkInitCallbackFailed(String str) {
+        for (String str2 : this.mAdUnitIdToListener.keySet()) {
+            RewardedVideoSmashListener rewardedVideoSmashListener = this.mAdUnitIdToListener.get(str2);
+            if (this.mAdUnitIdsForInitCallbacks.contains(str2)) {
+                rewardedVideoSmashListener.onRewardedVideoInitFailed(ErrorBuilder.buildInitFailedError(str, IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
+            } else {
+                rewardedVideoSmashListener.onRewardedVideoAvailabilityChanged(false);
+            }
+        }
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractRewardedVideoAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
+    public void loadRewardedVideo(@NonNull JSONObject jSONObject, JSONObject jSONObject2, @NonNull RewardedVideoSmashListener rewardedVideoSmashListener) {
+        loadRewardedVideoAdInternal(getConfigStringValueFromKey(jSONObject, getAdapter().getAdUnitIdKey()), jSONObject2, null, rewardedVideoSmashListener);
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractRewardedVideoAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
+    public void loadRewardedVideoForBidding(@NonNull JSONObject jSONObject, JSONObject jSONObject2, String str, @NonNull RewardedVideoSmashListener rewardedVideoSmashListener) {
+        loadRewardedVideoAdInternal(getConfigStringValueFromKey(jSONObject, getAdapter().getAdUnitIdKey()), jSONObject2, str, rewardedVideoSmashListener);
+    }
+
+    private void loadRewardedVideoAdInternal(final String str, final JSONObject jSONObject, final String str2, @NonNull final RewardedVideoSmashListener rewardedVideoSmashListener) {
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.rewardedvideo.AdMobRewardedVideoAdapter.1
+            @Override // java.lang.Runnable
+            public void run() {
+                IronLog.ADAPTER_API.verbose("adUnitId = " + str);
+                AdMobRewardedVideoAdapter.this.mAdUnitIdToAdsAvailability.put(str, Boolean.FALSE);
+                RewardedAd.load(ContextProvider.getInstance().getApplicationContext(), str, AdMobRewardedVideoAdapter.this.getAdapter().createAdRequest(jSONObject, str2), new AdMobRewardedVideoAdLoadListener(AdMobRewardedVideoAdapter.this, str, rewardedVideoSmashListener));
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractRewardedVideoAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
+    public void showRewardedVideo(@NonNull final JSONObject jSONObject, @NonNull final RewardedVideoSmashListener rewardedVideoSmashListener) {
+        postOnUIThread(new Runnable() { // from class: com.ironsource.adapters.admob.rewardedvideo.AdMobRewardedVideoAdapter.2
+            @Override // java.lang.Runnable
+            public void run() {
+                AdMobRewardedVideoAdapter adMobRewardedVideoAdapter = AdMobRewardedVideoAdapter.this;
+                String configStringValueFromKey = adMobRewardedVideoAdapter.getConfigStringValueFromKey(jSONObject, adMobRewardedVideoAdapter.getAdapter().getAdUnitIdKey());
+                RewardedAd rewardedVideoAd = AdMobRewardedVideoAdapter.this.getRewardedVideoAd(configStringValueFromKey);
+                IronLog.ADAPTER_API.verbose("adUnitId = " + configStringValueFromKey);
+                if (rewardedVideoAd != null && AdMobRewardedVideoAdapter.this.isRewardedVideoAvailableForAdUnitId(configStringValueFromKey)) {
+                    AdMobRewardedVideoAdShowListener adMobRewardedVideoAdShowListener = new AdMobRewardedVideoAdShowListener(configStringValueFromKey, rewardedVideoSmashListener);
+                    rewardedVideoAd.setFullScreenContentCallback(adMobRewardedVideoAdShowListener);
+                    rewardedVideoAd.show(ContextProvider.getInstance().getCurrentActiveActivity(), adMobRewardedVideoAdShowListener);
+                } else {
+                    rewardedVideoSmashListener.onRewardedVideoAdShowFailed(ErrorBuilder.buildNoAdsToShowError(IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
+                }
+                AdMobRewardedVideoAdapter.this.mAdUnitIdToAdsAvailability.put(configStringValueFromKey, Boolean.FALSE);
+            }
+        });
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractRewardedVideoAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
+    public boolean isRewardedVideoAvailable(@NonNull JSONObject jSONObject) {
+        return isRewardedVideoAvailableForAdUnitId(getConfigStringValueFromKey(jSONObject, getAdapter().getAdUnitIdKey()));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public boolean isRewardedVideoAvailableForAdUnitId(String str) {
+        return !TextUtils.isEmpty(str) && this.mAdUnitIdToAdsAvailability.containsKey(str) && this.mAdUnitIdToAdsAvailability.get(str).booleanValue();
+    }
+
+    @Override // com.ironsource.mediationsdk.sdk.ReleaseMemoryAdapterInterface
+    public void releaseMemory(@NonNull IronSource.AD_UNIT ad_unit, JSONObject jSONObject) {
+        Iterator<RewardedAd> it = this.mAdUnitIdToAd.values().iterator();
+        while (it.hasNext()) {
+            it.next().setFullScreenContentCallback(null);
+        }
+        this.mAdUnitIdToAd.clear();
+        this.mAdUnitIdToListener.clear();
+        this.mAdUnitIdToAdsAvailability.clear();
+        this.mAdUnitIdsForInitCallbacks.clear();
+        this.mAdUnitIdToAdData.clear();
+    }
+
+    @Override // com.ironsource.mediationsdk.adapter.AbstractRewardedVideoAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
+    public void collectRewardedVideoBiddingData(@NonNull JSONObject jSONObject, JSONObject jSONObject2, BiddingDataCallback biddingDataCallback) {
+        getAdapter().collectBiddingData(biddingDataCallback, AdFormat.REWARDED, null);
+    }
+
+    public void onRewardedVideoAdLoaded(String str, RewardedAd rewardedAd) {
+        this.mAdUnitIdToAd.put(str, rewardedAd);
+        this.mAdUnitIdToAdsAvailability.put(str, Boolean.TRUE);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public RewardedAd getRewardedVideoAd(String str) {
+        if (TextUtils.isEmpty(str) || !this.mAdUnitIdToAd.containsKey(str)) {
+            return null;
+        }
+        return this.mAdUnitIdToAd.get(str);
+    }
+}