rr3-apk/decompiled/sources/com/ironsource/adapters/unityads/UnityAdsAdapter.java

package com.ironsource.adapters.unityads;

import android.app.Activity;
import android.content.Context;
import android.text.TextUtils;
import android.widget.FrameLayout;
import com.ironsource.environment.ContextProvider;
import com.ironsource.mediationsdk.AbstractAdapter;
import com.ironsource.mediationsdk.AdapterUtils;
import com.ironsource.mediationsdk.INetworkInitCallbackListener;
import com.ironsource.mediationsdk.ISBannerSize;
import com.ironsource.mediationsdk.IntegrationData;
import com.ironsource.mediationsdk.IronSource;
import com.ironsource.mediationsdk.IronSourceBannerLayout;
import com.ironsource.mediationsdk.LoadWhileShowSupportState;
import com.ironsource.mediationsdk.logger.IronLog;
import com.ironsource.mediationsdk.logger.IronSourceError;
import com.ironsource.mediationsdk.metadata.MetaData;
import com.ironsource.mediationsdk.metadata.MetaDataUtils;
import com.ironsource.mediationsdk.sdk.BannerSmashListener;
import com.ironsource.mediationsdk.sdk.InterstitialSmashListener;
import com.ironsource.mediationsdk.sdk.RewardedVideoSmashListener;
import com.ironsource.mediationsdk.utils.ErrorBuilder;
import com.ironsource.mediationsdk.utils.IronSourceConstants;
import com.ironsource.mediationsdk.utils.IronSourceUtils;
import com.ironsource.v8;
import com.unity3d.ads.IUnityAdsInitializationListener;
import com.unity3d.ads.IUnityAdsTokenListener;
import com.unity3d.ads.UnityAds;
import com.unity3d.ads.UnityAdsLoadOptions;
import com.unity3d.ads.UnityAdsShowOptions;
import com.unity3d.ads.metadata.MediationMetaData;
import com.unity3d.ads.metadata.PlayerMetaData;
import com.unity3d.services.banners.BannerView;
import com.unity3d.services.banners.UnityBannerSize;
import com.unity3d.services.core.device.reader.JsonStorageKeyNames;
import com.vungle.ads.internal.protos.Sdk;
import csdk.gluads.Consts;
import csdk.gluads.ironsource.EAIronSource;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.atomic.AtomicBoolean;
import org.json.JSONObject;

/* loaded from: classes2.dex */
class UnityAdsAdapter extends AbstractAdapter implements IUnityAdsInitializationListener, INetworkInitCallbackListener {
    private static final String GitHash = "eb75e50";
    private static final String VERSION = "4.3.43";
    private final String ADAPTER_VERSION_KEY;
    private final String ADS_GATEWAY_ENABLED;
    private final String CONSENT_CCPA;
    private final String CONSENT_GDPR;
    private final String GAME_DESIGNATION;
    private final String GAME_ID;
    private final String LWS_SUPPORT_STATE;
    private final String MEDIATION_NAME;
    private final String MIXED_AUDIENCE;
    private final String PLACEMENT_ID;
    private final String UNITYADS_COPPA;
    private final String UNITYADS_METADATA_COPPA_KEY;
    private boolean isAdsGateway;
    protected ConcurrentHashMap<String, Boolean> mInterstitialAdsAvailability;
    private ConcurrentHashMap<String, String> mInterstitialPlacementIdToLoadedAdObjectId;
    private ConcurrentHashMap<String, BannerView> mPlacementIdToBannerAd;
    private ConcurrentHashMap<String, UnityAdsBannerListener> mPlacementIdToBannerListener;
    private ConcurrentHashMap<String, BannerSmashListener> mPlacementIdToBannerSmashListener;
    private ConcurrentHashMap<String, UnityAdsInterstitialListener> mPlacementIdToInterstitialListener;
    private ConcurrentHashMap<String, InterstitialSmashListener> mPlacementIdToInterstitialSmashListener;
    private ConcurrentHashMap<String, UnityAdsRewardedVideoListener> mPlacementIdToRewardedVideoListener;
    private ConcurrentHashMap<String, RewardedVideoSmashListener> mPlacementIdToRewardedVideoSmashListener;
    protected ConcurrentHashMap<String, Boolean> mRewardedVideoAdsAvailability;
    private ConcurrentHashMap<String, String> mRewardedVideoPlacementIdToLoadedAdObjectId;
    private CopyOnWriteArraySet<String> mRewardedVideoPlacementIdsForInitCallbacks;
    private final Object mUnityAdsStorageLock;
    private static HashSet<INetworkInitCallbackListener> initCallbackListeners = new HashSet<>();
    private static InitState mInitState = InitState.INIT_STATE_NONE;
    private static AtomicBoolean mWasInitCalled = new AtomicBoolean(false);
    private static String asyncToken = null;

    public enum InitState {
        INIT_STATE_NONE,
        INIT_STATE_IN_PROGRESS,
        INIT_STATE_SUCCESS,
        INIT_STATE_FAILED
    }

    private boolean isOSSupported() {
        return true;
    }

    @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 UnityAdsAdapter startAdapter(String str) {
        if (EAIronSource.adapterDisabled(UnityAdsAdapter.class.getName())) {
            return null;
        }
        return new UnityAdsAdapter(str);
    }

    private UnityAdsAdapter(String str) {
        super(str);
        this.MEDIATION_NAME = Consts.SDK_IRONSOURCE;
        this.ADAPTER_VERSION_KEY = "adapter_version";
        this.GAME_ID = "sourceId";
        this.PLACEMENT_ID = "zoneId";
        this.CONSENT_GDPR = "gdpr.consent";
        this.CONSENT_CCPA = "privacy.consent";
        this.UNITYADS_COPPA = JsonStorageKeyNames.USER_NON_BEHAVIORAL_KEY;
        this.UNITYADS_METADATA_COPPA_KEY = "unityads_coppa";
        this.GAME_DESIGNATION = v8.a.s;
        this.MIXED_AUDIENCE = "mixed";
        this.ADS_GATEWAY_ENABLED = "adsGatewayV2";
        this.LWS_SUPPORT_STATE = "isSupportedLWS";
        this.mUnityAdsStorageLock = new Object();
        this.isAdsGateway = false;
        IronLog.INTERNAL.verbose();
        this.mPlacementIdToRewardedVideoSmashListener = new ConcurrentHashMap<>();
        this.mPlacementIdToRewardedVideoListener = new ConcurrentHashMap<>();
        this.mRewardedVideoPlacementIdToLoadedAdObjectId = new ConcurrentHashMap<>();
        this.mRewardedVideoAdsAvailability = new ConcurrentHashMap<>();
        this.mRewardedVideoPlacementIdsForInitCallbacks = new CopyOnWriteArraySet<>();
        this.mPlacementIdToInterstitialSmashListener = new ConcurrentHashMap<>();
        this.mPlacementIdToInterstitialListener = new ConcurrentHashMap<>();
        this.mInterstitialPlacementIdToLoadedAdObjectId = new ConcurrentHashMap<>();
        this.mInterstitialAdsAvailability = new ConcurrentHashMap<>();
        this.mPlacementIdToBannerSmashListener = new ConcurrentHashMap<>();
        this.mPlacementIdToBannerListener = new ConcurrentHashMap<>();
        this.mPlacementIdToBannerAd = new ConcurrentHashMap<>();
    }

    public static IntegrationData getIntegrationData(Context context) {
        return new IntegrationData("UnityAds", VERSION);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter
    public String getCoreSDKVersion() {
        return UnityAds.getVersion();
    }

    public static String getAdapterSDKVersion() {
        return UnityAds.getVersion();
    }

    private void initSDK(String str, JSONObject jSONObject) {
        if (mInitState == InitState.INIT_STATE_NONE || mInitState == InitState.INIT_STATE_IN_PROGRESS) {
            initCallbackListeners.add(this);
        }
        if (mWasInitCalled.compareAndSet(false, true)) {
            IronLog.ADAPTER_API.verbose();
            mInitState = InitState.INIT_STATE_IN_PROGRESS;
            synchronized (this.mUnityAdsStorageLock) {
                MediationMetaData mediationMetaData = new MediationMetaData(ContextProvider.getInstance().getApplicationContext());
                mediationMetaData.setName(Consts.SDK_IRONSOURCE);
                mediationMetaData.setVersion(IronSourceUtils.getSDKVersion());
                mediationMetaData.set("adapter_version", VERSION);
                mediationMetaData.commit();
            }
            boolean optBoolean = jSONObject.optBoolean("adsGatewayV2", false);
            this.isAdsGateway = optBoolean;
            setUnityAdsMetaData("adsGatewayV2", optBoolean);
            UnityAds.setDebugMode(isAdaptersDebugEnabled());
            UnityAds.initialize(ContextProvider.getInstance().getApplicationContext(), str, false, this);
            if (this.isAdsGateway) {
                return;
            }
            getAsyncToken();
        }
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
    public void onNetworkInitCallbackSuccess() {
        IronLog.ADAPTER_CALLBACK.verbose();
        for (String str : this.mPlacementIdToRewardedVideoSmashListener.keySet()) {
            RewardedVideoSmashListener rewardedVideoSmashListener = this.mPlacementIdToRewardedVideoSmashListener.get(str);
            if (this.mRewardedVideoPlacementIdsForInitCallbacks.contains(str)) {
                rewardedVideoSmashListener.onRewardedVideoInitSuccess();
            } else {
                loadRewardedVideoInternal(str, null, rewardedVideoSmashListener);
            }
        }
        Iterator<InterstitialSmashListener> it = this.mPlacementIdToInterstitialSmashListener.values().iterator();
        while (it.hasNext()) {
            it.next().onInterstitialInitSuccess();
        }
        Iterator<BannerSmashListener> it2 = this.mPlacementIdToBannerSmashListener.values().iterator();
        while (it2.hasNext()) {
            it2.next().onBannerInitSuccess();
        }
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.INetworkInitCallbackListener
    public void onNetworkInitCallbackFailed(String str) {
        IronLog.ADAPTER_CALLBACK.verbose();
        for (String str2 : this.mPlacementIdToRewardedVideoSmashListener.keySet()) {
            RewardedVideoSmashListener rewardedVideoSmashListener = this.mPlacementIdToRewardedVideoSmashListener.get(str2);
            if (this.mRewardedVideoPlacementIdsForInitCallbacks.contains(str2)) {
                rewardedVideoSmashListener.onRewardedVideoInitFailed(ErrorBuilder.buildInitFailedError(str, IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
            } else {
                rewardedVideoSmashListener.onRewardedVideoAvailabilityChanged(false);
            }
        }
        Iterator<InterstitialSmashListener> it = this.mPlacementIdToInterstitialSmashListener.values().iterator();
        while (it.hasNext()) {
            it.next().onInterstitialInitFailed(ErrorBuilder.buildInitFailedError(str, "Interstitial"));
        }
        Iterator<BannerSmashListener> it2 = this.mPlacementIdToBannerSmashListener.values().iterator();
        while (it2.hasNext()) {
            it2.next().onBannerInitFailed(ErrorBuilder.buildInitFailedError(str, "Banner"));
        }
    }

    @Override // com.unity3d.ads.IUnityAdsInitializationListener
    public void onInitializationComplete() {
        IronLog.ADAPTER_CALLBACK.verbose();
        mInitState = InitState.INIT_STATE_SUCCESS;
        Iterator<INetworkInitCallbackListener> it = initCallbackListeners.iterator();
        while (it.hasNext()) {
            it.next().onNetworkInitCallbackSuccess();
        }
        initCallbackListeners.clear();
    }

    @Override // com.unity3d.ads.IUnityAdsInitializationListener
    public void onInitializationFailed(UnityAds.UnityAdsInitializationError unityAdsInitializationError, String str) {
        IronLog.ADAPTER_CALLBACK.verbose();
        mInitState = InitState.INIT_STATE_FAILED;
        String str2 = getUnityAdsInitializationErrorCode(unityAdsInitializationError) + str;
        Iterator<INetworkInitCallbackListener> it = initCallbackListeners.iterator();
        while (it.hasNext()) {
            it.next().onNetworkInitCallbackFailed(str2);
        }
        initCallbackListeners.clear();
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
    public void initRewardedVideoWithCallback(String str, String str2, JSONObject jSONObject, RewardedVideoSmashListener rewardedVideoSmashListener) {
        String optString = jSONObject.optString("sourceId");
        String optString2 = jSONObject.optString("zoneId");
        if (!isOSSupported()) {
            IronSourceError errorForUnsupportedAdapter = errorForUnsupportedAdapter(IronSourceConstants.REWARDED_VIDEO_AD_UNIT);
            IronLog.INTERNAL.error(errorForUnsupportedAdapter.getErrorMessage());
            rewardedVideoSmashListener.onRewardedVideoInitFailed(errorForUnsupportedAdapter);
            return;
        }
        if (TextUtils.isEmpty(optString)) {
            IronLog.INTERNAL.error("missing params = sourceId");
            rewardedVideoSmashListener.onRewardedVideoInitFailed(ErrorBuilder.buildInitFailedError("Missing params - sourceId", IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
            return;
        }
        if (TextUtils.isEmpty(optString2)) {
            IronLog.INTERNAL.error("missing params = zoneId");
            rewardedVideoSmashListener.onRewardedVideoInitFailed(ErrorBuilder.buildInitFailedError("Missing params - zoneId", IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
            return;
        }
        IronLog.ADAPTER_API.verbose("gameId = " + optString + ", placementId = " + optString2);
        this.mPlacementIdToRewardedVideoSmashListener.put(optString2, rewardedVideoSmashListener);
        this.mRewardedVideoPlacementIdsForInitCallbacks.add(optString2);
        int i = AnonymousClass2.$SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState[mInitState.ordinal()];
        if (i == 1 || i == 2) {
            initSDK(optString, jSONObject);
        } else if (i == 3) {
            rewardedVideoSmashListener.onRewardedVideoInitSuccess();
        } else {
            if (i != 4) {
                return;
            }
            rewardedVideoSmashListener.onRewardedVideoInitFailed(ErrorBuilder.buildInitFailedError("UnityAds SDK init failed", IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
        }
    }

    /* renamed from: com.ironsource.adapters.unityads.UnityAdsAdapter$2, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass2 {
        static final /* synthetic */ int[] $SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState;

        static {
            int[] iArr = new int[InitState.values().length];
            $SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState = iArr;
            try {
                iArr[InitState.INIT_STATE_NONE.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState[InitState.INIT_STATE_IN_PROGRESS.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState[InitState.INIT_STATE_SUCCESS.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState[InitState.INIT_STATE_FAILED.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
        }
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
    public void initAndLoadRewardedVideo(String str, String str2, JSONObject jSONObject, JSONObject jSONObject2, RewardedVideoSmashListener rewardedVideoSmashListener) {
        String optString = jSONObject.optString("sourceId");
        String optString2 = jSONObject.optString("zoneId");
        if (!isOSSupported()) {
            IronLog.INTERNAL.error(errorForUnsupportedAdapter(IronSourceConstants.REWARDED_VIDEO_AD_UNIT).getErrorMessage());
            rewardedVideoSmashListener.onRewardedVideoAvailabilityChanged(false);
            return;
        }
        if (TextUtils.isEmpty(optString)) {
            IronLog.INTERNAL.error("missing params = sourceId");
            rewardedVideoSmashListener.onRewardedVideoAvailabilityChanged(false);
            return;
        }
        if (TextUtils.isEmpty(optString2)) {
            IronLog.INTERNAL.error("missing params = zoneId");
            rewardedVideoSmashListener.onRewardedVideoAvailabilityChanged(false);
            return;
        }
        IronLog.ADAPTER_API.verbose("gameId = " + optString + ", placementId = " + optString2);
        this.mPlacementIdToRewardedVideoSmashListener.put(optString2, rewardedVideoSmashListener);
        int i = AnonymousClass2.$SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState[mInitState.ordinal()];
        if (i == 1 || i == 2) {
            initSDK(optString, jSONObject);
        } else if (i == 3) {
            loadRewardedVideoInternal(optString2, null, rewardedVideoSmashListener);
        } else {
            if (i != 4) {
                return;
            }
            rewardedVideoSmashListener.onRewardedVideoAvailabilityChanged(false);
        }
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
    public void loadRewardedVideoForBidding(JSONObject jSONObject, JSONObject jSONObject2, String str, RewardedVideoSmashListener rewardedVideoSmashListener) {
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        loadRewardedVideoInternal(optString, str, rewardedVideoSmashListener);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
    public void loadRewardedVideo(JSONObject jSONObject, JSONObject jSONObject2, RewardedVideoSmashListener rewardedVideoSmashListener) {
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        loadRewardedVideoInternal(optString, null, rewardedVideoSmashListener);
    }

    private void loadRewardedVideoInternal(String str, String str2, RewardedVideoSmashListener rewardedVideoSmashListener) {
        IronLog.ADAPTER_API.verbose("placementId = " + str);
        this.mRewardedVideoAdsAvailability.put(str, Boolean.FALSE);
        UnityAdsRewardedVideoListener unityAdsRewardedVideoListener = new UnityAdsRewardedVideoListener(this, rewardedVideoSmashListener, str);
        this.mPlacementIdToRewardedVideoListener.put(str, unityAdsRewardedVideoListener);
        UnityAdsLoadOptions unityAdsLoadOptions = new UnityAdsLoadOptions();
        String uuid = UUID.randomUUID().toString();
        unityAdsLoadOptions.setObjectId(uuid);
        if (!TextUtils.isEmpty(str2)) {
            unityAdsLoadOptions.setAdMarkup(str2);
        }
        this.mRewardedVideoPlacementIdToLoadedAdObjectId.put(str, uuid);
        UnityAds.load(str, unityAdsLoadOptions, unityAdsRewardedVideoListener);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
    public void showRewardedVideo(JSONObject jSONObject, RewardedVideoSmashListener rewardedVideoSmashListener) {
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        if (isRewardedVideoAvailable(jSONObject)) {
            this.mRewardedVideoAdsAvailability.put(optString, Boolean.FALSE);
            if (!TextUtils.isEmpty(getDynamicUserId())) {
                synchronized (this.mUnityAdsStorageLock) {
                    PlayerMetaData playerMetaData = new PlayerMetaData(ContextProvider.getInstance().getApplicationContext());
                    playerMetaData.setServerId(getDynamicUserId());
                    playerMetaData.commit();
                }
            }
            UnityAdsRewardedVideoListener unityAdsRewardedVideoListener = this.mPlacementIdToRewardedVideoListener.get(optString);
            String str = this.mRewardedVideoPlacementIdToLoadedAdObjectId.get(optString);
            UnityAdsShowOptions unityAdsShowOptions = new UnityAdsShowOptions();
            unityAdsShowOptions.setObjectId(str);
            UnityAds.show(ContextProvider.getInstance().getCurrentActiveActivity(), optString, unityAdsShowOptions, unityAdsRewardedVideoListener);
            return;
        }
        rewardedVideoSmashListener.onRewardedVideoAdShowFailed(ErrorBuilder.buildNoAdsToShowError(IronSourceConstants.REWARDED_VIDEO_AD_UNIT));
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
    public boolean isRewardedVideoAvailable(JSONObject jSONObject) {
        if (!isOSSupported()) {
            IronLog.INTERNAL.error(errorForUnsupportedAdapter(IronSourceConstants.REWARDED_VIDEO_AD_UNIT).getErrorMessage());
            return false;
        }
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        return this.mRewardedVideoAdsAvailability.containsKey(optString) && this.mRewardedVideoAdsAvailability.get(optString).booleanValue();
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.RewardedVideoAdapterInterface
    public Map<String, Object> getRewardedVideoBiddingData(JSONObject jSONObject, JSONObject jSONObject2) {
        return getBiddingData();
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
    public void initInterstitialForBidding(String str, String str2, JSONObject jSONObject, InterstitialSmashListener interstitialSmashListener) {
        IronLog.ADAPTER_API.verbose();
        initInterstitial(str, str2, jSONObject, interstitialSmashListener);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
    public void initInterstitial(String str, String str2, JSONObject jSONObject, InterstitialSmashListener interstitialSmashListener) {
        String optString = jSONObject.optString("sourceId");
        String optString2 = jSONObject.optString("zoneId");
        if (!isOSSupported()) {
            IronSourceError errorForUnsupportedAdapter = errorForUnsupportedAdapter("Interstitial");
            IronLog.INTERNAL.error(errorForUnsupportedAdapter.getErrorMessage());
            interstitialSmashListener.onInterstitialInitFailed(errorForUnsupportedAdapter);
            return;
        }
        if (TextUtils.isEmpty(optString)) {
            IronLog.INTERNAL.error("missing params = sourceId");
            interstitialSmashListener.onInterstitialInitFailed(ErrorBuilder.buildInitFailedError("Missing params - sourceId", "Interstitial"));
            return;
        }
        if (TextUtils.isEmpty(optString2)) {
            IronLog.INTERNAL.error("missing params = zoneId");
            interstitialSmashListener.onInterstitialInitFailed(ErrorBuilder.buildInitFailedError("Missing params - zoneId", "Interstitial"));
            return;
        }
        IronLog.ADAPTER_API.verbose("gameId = " + optString + ", placementId = " + optString2);
        this.mPlacementIdToInterstitialSmashListener.put(optString2, interstitialSmashListener);
        int i = AnonymousClass2.$SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState[mInitState.ordinal()];
        if (i == 1 || i == 2) {
            initSDK(optString, jSONObject);
        } else if (i == 3) {
            interstitialSmashListener.onInterstitialInitSuccess();
        } else {
            if (i != 4) {
                return;
            }
            interstitialSmashListener.onInterstitialInitFailed(ErrorBuilder.buildInitFailedError("UnityAds SDK init failed", "Interstitial"));
        }
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
    public void loadInterstitialForBidding(JSONObject jSONObject, JSONObject jSONObject2, String str, InterstitialSmashListener interstitialSmashListener) {
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        loadInterstitialInternal(jSONObject, interstitialSmashListener, str, optString);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
    public void loadInterstitial(JSONObject jSONObject, JSONObject jSONObject2, InterstitialSmashListener interstitialSmashListener) {
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        loadInterstitialInternal(jSONObject, interstitialSmashListener, null, optString);
    }

    private void loadInterstitialInternal(JSONObject jSONObject, InterstitialSmashListener interstitialSmashListener, String str, String str2) {
        IronLog.ADAPTER_API.verbose("placementId = " + str2);
        this.mInterstitialAdsAvailability.put(str2, Boolean.FALSE);
        UnityAdsInterstitialListener unityAdsInterstitialListener = new UnityAdsInterstitialListener(this, interstitialSmashListener, str2);
        this.mPlacementIdToInterstitialListener.put(str2, unityAdsInterstitialListener);
        UnityAdsLoadOptions unityAdsLoadOptions = new UnityAdsLoadOptions();
        String uuid = UUID.randomUUID().toString();
        unityAdsLoadOptions.setObjectId(uuid);
        if (!TextUtils.isEmpty(str)) {
            unityAdsLoadOptions.setAdMarkup(str);
        }
        this.mInterstitialPlacementIdToLoadedAdObjectId.put(str2, uuid);
        UnityAds.load(str2, unityAdsLoadOptions, unityAdsInterstitialListener);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
    public void showInterstitial(JSONObject jSONObject, InterstitialSmashListener interstitialSmashListener) {
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        if (isInterstitialReady(jSONObject)) {
            this.mInterstitialAdsAvailability.put(optString, Boolean.FALSE);
            Activity currentActiveActivity = ContextProvider.getInstance().getCurrentActiveActivity();
            UnityAdsInterstitialListener unityAdsInterstitialListener = this.mPlacementIdToInterstitialListener.get(optString);
            String str = this.mInterstitialPlacementIdToLoadedAdObjectId.get(optString);
            UnityAdsShowOptions unityAdsShowOptions = new UnityAdsShowOptions();
            unityAdsShowOptions.setObjectId(str);
            UnityAds.show(currentActiveActivity, optString, unityAdsShowOptions, unityAdsInterstitialListener);
            return;
        }
        interstitialSmashListener.onInterstitialAdShowFailed(ErrorBuilder.buildNoAdsToShowError("Interstitial"));
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
    public boolean isInterstitialReady(JSONObject jSONObject) {
        if (!isOSSupported()) {
            IronLog.INTERNAL.error(errorForUnsupportedAdapter("Interstitial").getErrorMessage());
            return false;
        }
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        return this.mInterstitialAdsAvailability.containsKey(optString) && this.mInterstitialAdsAvailability.get(optString).booleanValue();
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.InterstitialAdapterInterface
    public Map<String, Object> getInterstitialBiddingData(JSONObject jSONObject, JSONObject jSONObject2) {
        return getBiddingData();
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
    public void initBannerForBidding(String str, String str2, JSONObject jSONObject, BannerSmashListener bannerSmashListener) {
        initBanners(str, str2, jSONObject, bannerSmashListener);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
    public void initBanners(String str, String str2, JSONObject jSONObject, BannerSmashListener bannerSmashListener) {
        String optString = jSONObject.optString("sourceId");
        String optString2 = jSONObject.optString("zoneId");
        if (!isOSSupported()) {
            IronSourceError errorForUnsupportedAdapter = errorForUnsupportedAdapter("Banner");
            IronLog.INTERNAL.error(errorForUnsupportedAdapter.getErrorMessage());
            bannerSmashListener.onBannerInitFailed(errorForUnsupportedAdapter);
            return;
        }
        if (TextUtils.isEmpty(optString)) {
            IronLog.INTERNAL.error("missing params = sourceId");
            bannerSmashListener.onBannerInitFailed(ErrorBuilder.buildInitFailedError("Missing params - sourceId", "Banner"));
            return;
        }
        if (TextUtils.isEmpty(optString2)) {
            IronLog.INTERNAL.error("missing params = zoneId");
            bannerSmashListener.onBannerInitFailed(ErrorBuilder.buildInitFailedError("Missing params - zoneId", "Banner"));
            return;
        }
        IronLog.ADAPTER_API.verbose("gameId = " + optString + ", placementId = " + optString2);
        this.mPlacementIdToBannerSmashListener.put(optString2, bannerSmashListener);
        int i = AnonymousClass2.$SwitchMap$com$ironsource$adapters$unityads$UnityAdsAdapter$InitState[mInitState.ordinal()];
        if (i == 1 || i == 2) {
            initSDK(optString, jSONObject);
        } else if (i == 3) {
            bannerSmashListener.onBannerInitSuccess();
        } else {
            if (i != 4) {
                return;
            }
            bannerSmashListener.onBannerInitFailed(ErrorBuilder.buildInitFailedError("UnityAds SDK init failed", "Banner"));
        }
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
    public void loadBannerForBidding(JSONObject jSONObject, JSONObject jSONObject2, String str, IronSourceBannerLayout ironSourceBannerLayout, BannerSmashListener bannerSmashListener) {
        loadBannerInternal(jSONObject, jSONObject2, ironSourceBannerLayout, bannerSmashListener, str);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
    public void loadBanner(JSONObject jSONObject, JSONObject jSONObject2, IronSourceBannerLayout ironSourceBannerLayout, BannerSmashListener bannerSmashListener) {
        loadBannerInternal(jSONObject, jSONObject2, ironSourceBannerLayout, bannerSmashListener, null);
    }

    public void loadBannerInternal(JSONObject jSONObject, JSONObject jSONObject2, IronSourceBannerLayout ironSourceBannerLayout, BannerSmashListener bannerSmashListener, String str) {
        String optString = jSONObject.optString("zoneId");
        if (ironSourceBannerLayout == null) {
            IronLog.INTERNAL.error("banner is null");
            bannerSmashListener.onBannerAdLoadFailed(ErrorBuilder.buildNoConfigurationAvailableError("banner is null"));
            return;
        }
        if (!isBannerSizeSupported(ironSourceBannerLayout.getSize()).booleanValue()) {
            IronLog.ADAPTER_API.verbose("size not supported, size = " + ironSourceBannerLayout.getSize().getDescription());
            bannerSmashListener.onBannerAdLoadFailed(ErrorBuilder.unsupportedBannerSize(getProviderName()));
            return;
        }
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        BannerView bannerView = getBannerView(ironSourceBannerLayout, optString, bannerSmashListener);
        UnityAdsLoadOptions unityAdsLoadOptions = new UnityAdsLoadOptions();
        unityAdsLoadOptions.setObjectId(UUID.randomUUID().toString());
        if (!TextUtils.isEmpty(str)) {
            unityAdsLoadOptions.setAdMarkup(str);
        }
        bannerView.load(unityAdsLoadOptions);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
    public void destroyBanner(JSONObject jSONObject) {
        String optString = jSONObject.optString("zoneId");
        IronLog.ADAPTER_API.verbose("placementId = " + optString);
        if (this.mPlacementIdToBannerAd.get(optString) != null) {
            this.mPlacementIdToBannerAd.get(optString).destroy();
            this.mPlacementIdToBannerAd.remove(optString);
        }
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.BannerAdapterInterface
    public Map<String, Object> getBannerBiddingData(JSONObject jSONObject, JSONObject jSONObject2) {
        return getBiddingData();
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter, com.ironsource.mediationsdk.sdk.ReleaseMemoryAdapterInterface
    public void releaseMemory(IronSource.AD_UNIT ad_unit, JSONObject jSONObject) {
        IronLog.INTERNAL.verbose("adUnit = " + ad_unit);
        if (ad_unit == IronSource.AD_UNIT.REWARDED_VIDEO) {
            this.mPlacementIdToRewardedVideoSmashListener.clear();
            this.mPlacementIdToRewardedVideoListener.clear();
            this.mRewardedVideoPlacementIdToLoadedAdObjectId.clear();
            this.mRewardedVideoAdsAvailability.clear();
            this.mRewardedVideoPlacementIdsForInitCallbacks.clear();
            return;
        }
        if (ad_unit == IronSource.AD_UNIT.INTERSTITIAL) {
            this.mPlacementIdToInterstitialSmashListener.clear();
            this.mPlacementIdToInterstitialListener.clear();
            this.mInterstitialPlacementIdToLoadedAdObjectId.clear();
            this.mInterstitialAdsAvailability.clear();
            return;
        }
        if (ad_unit == IronSource.AD_UNIT.BANNER) {
            Iterator<BannerView> it = this.mPlacementIdToBannerAd.values().iterator();
            while (it.hasNext()) {
                it.next().destroy();
            }
            this.mPlacementIdToBannerSmashListener.clear();
            this.mPlacementIdToBannerListener.clear();
            this.mPlacementIdToBannerAd.clear();
        }
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter
    public void setConsent(boolean z) {
        IronLog.ADAPTER_API.verbose("setConsent = " + z);
        setUnityAdsMetaData("gdpr.consent", z);
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter
    public void setMetaData(String str, List<String> list) {
        if (list.isEmpty()) {
            return;
        }
        String str2 = list.get(0);
        IronLog.ADAPTER_API.verbose("key = " + str + ", value = " + str2);
        if (MetaDataUtils.isValidCCPAMetaData(str, str2)) {
            setCCPAValue(MetaDataUtils.getMetaDataBooleanValue(str2));
            return;
        }
        String formatValueForType = MetaDataUtils.formatValueForType(str2, MetaData.MetaDataValueTypes.META_DATA_VALUE_BOOLEAN);
        if (MetaDataUtils.isValidMetaData(str, "unityads_coppa", formatValueForType)) {
            setCOPPAValue(MetaDataUtils.getMetaDataBooleanValue(formatValueForType));
        }
    }

    private void setUnityAdsMetaData(String str, boolean z) {
        IronLog.INTERNAL.verbose("key = " + str + "value = " + z);
        synchronized (this.mUnityAdsStorageLock) {
            try {
                com.unity3d.ads.metadata.MetaData metaData = new com.unity3d.ads.metadata.MetaData(ContextProvider.getInstance().getApplicationContext());
                metaData.set(str, Boolean.valueOf(z));
                if (str.equals(JsonStorageKeyNames.USER_NON_BEHAVIORAL_KEY)) {
                    metaData.set(v8.a.s, "mixed");
                }
                metaData.commit();
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    private void setCOPPAValue(boolean z) {
        IronLog.ADAPTER_API.verbose("value = " + z);
        setUnityAdsMetaData(JsonStorageKeyNames.USER_NON_BEHAVIORAL_KEY, z);
    }

    private void setCCPAValue(boolean z) {
        IronLog.ADAPTER_API.verbose("value = " + z);
        setUnityAdsMetaData("privacy.consent", z ^ true);
    }

    private Map<String, Object> getBiddingData() {
        String str;
        if (this.isAdsGateway) {
            str = UnityAds.getToken();
        } else if (InitState.INIT_STATE_SUCCESS == mInitState) {
            str = UnityAds.getToken();
        } else if (!TextUtils.isEmpty(asyncToken)) {
            str = asyncToken;
            getAsyncToken();
        } else {
            IronLog.INTERNAL.verbose("returning null as token since init did not finish successfully and async token did not return");
            return null;
        }
        if (TextUtils.isEmpty(str)) {
            str = "";
        }
        IronLog.ADAPTER_API.verbose("token = " + str);
        HashMap hashMap = new HashMap();
        hashMap.put("token", str);
        return hashMap;
    }

    private Boolean isBannerSizeSupported(ISBannerSize iSBannerSize) {
        String description = iSBannerSize.getDescription();
        description.hashCode();
        switch (description) {
            case "RECTANGLE":
            case "LARGE":
            case "SMART":
            case "BANNER":
                return Boolean.TRUE;
            default:
                return Boolean.FALSE;
        }
    }

    private UnityBannerSize getBannerSize(ISBannerSize iSBannerSize, boolean z) {
        String description = iSBannerSize.getDescription();
        description.hashCode();
        switch (description) {
            case "RECTANGLE":
                return new UnityBannerSize(300, 250);
            case "LARGE":
            case "BANNER":
                return new UnityBannerSize(Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE, 50);
            case "SMART":
                return z ? new UnityBannerSize(728, 90) : new UnityBannerSize(Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE, 50);
            default:
                return null;
        }
    }

    private BannerView getBannerView(IronSourceBannerLayout ironSourceBannerLayout, String str, BannerSmashListener bannerSmashListener) {
        if (this.mPlacementIdToBannerAd.get(str) != null) {
            this.mPlacementIdToBannerAd.get(str).destroy();
            this.mPlacementIdToBannerAd.remove(str);
        }
        BannerView bannerView = new BannerView(ContextProvider.getInstance().getCurrentActiveActivity(), str, getBannerSize(ironSourceBannerLayout.getSize(), AdapterUtils.isLargeScreen(ContextProvider.getInstance().getApplicationContext())));
        UnityAdsBannerListener unityAdsBannerListener = new UnityAdsBannerListener(this, bannerSmashListener, str);
        this.mPlacementIdToBannerListener.put(str, unityAdsBannerListener);
        bannerView.setListener(unityAdsBannerListener);
        this.mPlacementIdToBannerAd.put(str, bannerView);
        return bannerView;
    }

    public FrameLayout.LayoutParams createLayoutParams(UnityBannerSize unityBannerSize) {
        return new FrameLayout.LayoutParams(AdapterUtils.dpToPixels(ContextProvider.getInstance().getApplicationContext(), unityBannerSize.getWidth()), -2, 17);
    }

    private IronSourceError errorForUnsupportedAdapter(String str) {
        return ErrorBuilder.buildInitFailedError("UnityAds SDK version is not supported", str);
    }

    private int getUnityAdsInitializationErrorCode(UnityAds.UnityAdsInitializationError unityAdsInitializationError) {
        if (unityAdsInitializationError == null) {
            return 510;
        }
        for (UnityAds.UnityAdsInitializationError unityAdsInitializationError2 : UnityAds.UnityAdsInitializationError.values()) {
            if (unityAdsInitializationError2.name().equalsIgnoreCase(unityAdsInitializationError.toString())) {
                return UnityAds.UnityAdsInitializationError.valueOf(unityAdsInitializationError.toString()).ordinal();
            }
        }
        return 510;
    }

    public int getUnityAdsLoadErrorCode(UnityAds.UnityAdsLoadError unityAdsLoadError) {
        if (unityAdsLoadError == null) {
            return 510;
        }
        for (UnityAds.UnityAdsLoadError unityAdsLoadError2 : UnityAds.UnityAdsLoadError.values()) {
            if (unityAdsLoadError2.name().equalsIgnoreCase(unityAdsLoadError.toString())) {
                return UnityAds.UnityAdsLoadError.valueOf(unityAdsLoadError.toString()).ordinal();
            }
        }
        return 510;
    }

    public int getUnityAdsShowErrorCode(UnityAds.UnityAdsShowError unityAdsShowError) {
        if (unityAdsShowError == null) {
            return 510;
        }
        for (UnityAds.UnityAdsShowError unityAdsShowError2 : UnityAds.UnityAdsShowError.values()) {
            if (unityAdsShowError2.name().equalsIgnoreCase(unityAdsShowError.toString())) {
                return UnityAds.UnityAdsShowError.valueOf(unityAdsShowError.toString()).ordinal();
            }
        }
        return 510;
    }

    @Override // com.ironsource.mediationsdk.AbstractAdapter
    public LoadWhileShowSupportState getLoadWhileShowSupportState(JSONObject jSONObject) {
        LoadWhileShowSupportState loadWhileShowSupportState = LoadWhileShowSupportState.LOAD_WHILE_SHOW_BY_INSTANCE;
        return (jSONObject == null || jSONObject.optBoolean("isSupportedLWS", true)) ? loadWhileShowSupportState : LoadWhileShowSupportState.NONE;
    }

    public void getAsyncToken() {
        IronLog.INTERNAL.verbose();
        UnityAds.getToken(new IUnityAdsTokenListener() { // from class: com.ironsource.adapters.unityads.UnityAdsAdapter.1
            @Override // com.unity3d.ads.IUnityAdsTokenListener
            public void onUnityAdsTokenReady(String str) {
                IronLog.ADAPTER_CALLBACK.verbose("async token returned");
                String unused = UnityAdsAdapter.asyncToken = str;
            }
        });
    }
}