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