package csdk.gluads.max;

import android.app.Activity;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import com.applovin.mediation.adapter.MaxAdapter;
import com.applovin.mediation.adapter.listeners.MaxInterstitialAdapterListener;
import com.applovin.mediation.adapter.listeners.MaxRewardedAdapterListener;
import com.applovin.mediation.adapter.listeners.MaxRewardedInterstitialAdapterListener;
import com.applovin.mediation.adapter.listeners.MaxSignalCollectionListener;
import com.applovin.sdk.AppLovinPrivacySettings;
import com.applovin.sdk.AppLovinSdk;
import com.applovin.sdk.AppLovinSdkConfiguration;
import com.applovin.sdk.AppLovinSdkSettings;
import com.facebook.ads.AdSettings;
import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
import csdk.gluads.Consts;
import csdk.gluads.CustomSettings;
import csdk.gluads.GluAdsFactory;
import csdk.gluads.IAdvertising;
import csdk.gluads.PrivacyStatus;
import csdk.gluads.eventbus.GluEventBus;
import csdk.gluads.impl.AdvertisingImpl;
import csdk.gluads.impl.DummyAdvertising;
import csdk.gluads.util.AdvertisingUtil;
import csdk.gluads.util.Common;
import csdk.gluads.util.ConfigUtil;
import csdk.gluads.util.Futures;
import csdk.gluads.util.IAction1;
import csdk.gluads.util.log.YLogger;
import csdk.gluads.util.log.YLoggerFactory;
import csdk.gluads.util.log.YLoggers;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;

/* loaded from: classes4.dex */
public class EAMax {
    private static final YLogger log = YLoggerFactory.getLogger((Class<?>) EAMax.class);
    private static Map<String, String> mAdapterNames;
    private static Set<String> mDisabledAdapters;
    private static AppLovinSdk mSdk;

    static {
        HashMap hashMap = new HashMap();
        mAdapterNames = hashMap;
        hashMap.put(Consts.SDK_FACEBOOK_AUDIENCE_NETWORK, "com.applovin.mediation.adapters.FacebookMediationAdapter");
        mAdapterNames.put("fyber", "com.applovin.mediation.adapters.InneractiveMediationAdapter");
        mAdapterNames.put(Consts.SDK_ADMOB, "com.applovin.mediation.adapters.GoogleMediationAdapter");
        mAdapterNames.put("gam", "com.applovin.mediation.adapters.GoogleAdManagerMediationAdapter");
        mAdapterNames.put(Consts.SDK_IRONSOURCE, "com.applovin.mediation.adapters.IronSourceMediationAdapter");
        mAdapterNames.put(Consts.SDK_MINTEGRAL, "com.applovin.mediation.adapters.MintegralMediationAdapter");
        mAdapterNames.put(Consts.SDK_TAPJOY, "com.applovin.mediation.adapters.TapjoyMediationAdapter");
        mAdapterNames.put(Consts.SDK_UNITY_ADS, "com.applovin.mediation.adapters.UnityAdsMediationAdapter");
        mAdapterNames.put(Consts.SDK_VUNGLE, "com.applovin.mediation.adapters.VungleMediationAdapter");
    }

    public static boolean isAdapterDisabled(String str) {
        return mDisabledAdapters.contains(str);
    }

    public static boolean adapterDisabled(String str, MaxAdapter.OnCompletionListener onCompletionListener) {
        if (!isAdapterDisabled(str)) {
            return false;
        }
        if (onCompletionListener == null) {
            return true;
        }
        onCompletionListener.onCompletion(MaxAdapter.InitializationStatus.INITIALIZED_FAILURE, null);
        return true;
    }

    public static boolean adapterDisabled(String str, MaxInterstitialAdapterListener maxInterstitialAdapterListener) {
        if (!isAdapterDisabled(str)) {
            return false;
        }
        if (maxInterstitialAdapterListener == null) {
            return true;
        }
        maxInterstitialAdapterListener.onInterstitialAdLoadFailed(null);
        return true;
    }

    public static boolean adapterDisabled(String str, MaxRewardedInterstitialAdapterListener maxRewardedInterstitialAdapterListener) {
        if (!isAdapterDisabled(str)) {
            return false;
        }
        if (maxRewardedInterstitialAdapterListener == null) {
            return true;
        }
        maxRewardedInterstitialAdapterListener.onRewardedInterstitialAdLoadFailed(null);
        return true;
    }

    public static boolean adapterDisabled(String str, MaxRewardedAdapterListener maxRewardedAdapterListener) {
        if (!isAdapterDisabled(str)) {
            return false;
        }
        if (maxRewardedAdapterListener == null) {
            return true;
        }
        maxRewardedAdapterListener.onRewardedAdLoadFailed(null);
        return true;
    }

    public static boolean adapterDisabled(String str, MaxSignalCollectionListener maxSignalCollectionListener) {
        if (!isAdapterDisabled(str)) {
            return false;
        }
        if (maxSignalCollectionListener == null) {
            return true;
        }
        maxSignalCollectionListener.onSignalCollectionFailed(str + " is disabled");
        return true;
    }

    public static Future<?> createMAX(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @NonNull CustomSettings customSettings, boolean z, PrivacyStatus privacyStatus, @NonNull final AdvertisingImpl advertisingImpl) {
        mDisabledAdapters = new HashSet();
        Map<String, Object> configDisabled = GluAdsFactory.configDisabled(map);
        final Activity activity = (Activity) Common.call(callable);
        IAction1<PrivacyStatus> iAction1 = new IAction1<PrivacyStatus>() { // from class: csdk.gluads.max.EAMax.1
            @Override // csdk.gluads.util.IAction1
            public void apply(PrivacyStatus privacyStatus2) {
            }
        };
        for (String str : Consts.SDK_ARRAY_AD_NETWORKS) {
            if (ConfigUtil.getBoolean(configDisabled, str)) {
                mDisabledAdapters.add(getAdapterClassName(str));
            }
            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, str, Consts.SDK_PRIVACY_STAGE_ADDED, iAction1, advertisingImpl);
        }
        if (ConfigUtil.getBoolean(configDisabled, "gam")) {
            mDisabledAdapters.add(getAdapterClassName("gam"));
        }
        final String string = ConfigUtil.getString(ConfigUtil.configSdk(map), "appLovin.sdkKey");
        if (TextUtils.isEmpty(string)) {
            YLoggers.sdkConfiguration(log, Consts.SDK_APPLOVIN, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE, Consts.KEY_TAPJOY_USER_ID_VERSION, "AppLovin SDK key is null or empty");
            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_APPLOVIN, "disabled", null, advertisingImpl);
            return GluAdsFactory.disabledFuture();
        }
        final AppLovinSdkSettings appLovinSdkSettings = new AppLovinSdkSettings(activity);
        appLovinSdkSettings.setVerboseLogging(z);
        if (!z) {
            appLovinSdkSettings.setCreativeDebuggerEnabled(false);
        }
        if (ConfigUtil.getBoolean(ConfigUtil.configSdk(map), "debug.maxTestMode")) {
            String gaid = Common.getGAID(activity);
            if (!TextUtils.isEmpty(gaid)) {
                appLovinSdkSettings.setTestDeviceAdvertisingIds(Arrays.asList(gaid));
            }
        }
        AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_APPLOVIN, Consts.SDK_PRIVACY_STAGE_ADDED, new IAction1<PrivacyStatus>() { // from class: csdk.gluads.max.EAMax.2
            @Override // csdk.gluads.util.IAction1
            public void apply(PrivacyStatus privacyStatus2) {
                if (privacyStatus2.gdprApplies) {
                    AppLovinSdkSettings.this.setExtraParameter("consent_dialog_state", "applies");
                    AppLovinSdkSettings.this.setExtraParameter("huc", Boolean.toString(privacyStatus2.hasConsent));
                    AppLovinPrivacySettings.setHasUserConsent(privacyStatus2.hasConsent, activity);
                }
                if (privacyStatus2.ccpaApplies) {
                    AppLovinSdkSettings.this.setExtraParameter("dns", Boolean.toString(privacyStatus2.ccpaOptOut));
                    AppLovinPrivacySettings.setDoNotSell(privacyStatus2.ccpaOptOut, activity);
                }
                if (privacyStatus2.ccpaOptOut) {
                    AdSettings.setDataProcessingOptions(new String[]{"LDU"}, 0, 0);
                } else {
                    AdSettings.setDataProcessingOptions(new String[0]);
                }
                if (AppLovinPrivacySettings.getAdditionalConsentStatus(89) != null) {
                    AdSettings.setDataProcessingOptions(new String[]{"LDU"}, 0, 0);
                }
                AppLovinSdk appLovinSdk = AppLovinSdk.getInstance(string, AppLovinSdkSettings.this, activity);
                if (appLovinSdk == null) {
                    EAMax.log.e("max", "Cannot acces AppLovinSdk instance");
                    AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_APPLOVIN, "disabled", null, advertisingImpl);
                    return;
                }
                Map<String, IAdvertising> componentHandlers = advertisingImpl.getComponentHandlers();
                boolean z2 = true;
                for (Map.Entry<String, IAdvertising> entry : componentHandlers.entrySet()) {
                    IAdvertising value = entry.getValue();
                    if (value != null) {
                        try {
                            componentHandlers.put(entry.getKey(), ((EAMaxManagerProxy) value).createManager(appLovinSdk));
                            z2 = false;
                        } catch (ClassCastException unused) {
                        }
                    }
                }
                if (z2) {
                    return;
                }
                appLovinSdk.setMediationProvider("max");
                AppLovinSdk unused2 = EAMax.mSdk = appLovinSdk;
                EAMax.log.d("SDK.VERSION", Consts.SDK_APPLOVIN, AppLovinSdk.VERSION, InneractiveMediationDefs.GENDER_MALE, "sdkInitialize begin");
                EAMax.mSdk.initializeSdk(new AppLovinSdk.SdkInitializationListener() { // from class: csdk.gluads.max.EAMax.2.1
                    @Override // com.applovin.sdk.AppLovinSdk.SdkInitializationListener
                    public void onSdkInitialized(AppLovinSdkConfiguration appLovinSdkConfiguration) {
                        EAMax.log.d("SDK.VERSION", Consts.SDK_APPLOVIN, AppLovinSdk.VERSION, InneractiveMediationDefs.GENDER_MALE, "onSdkInitialized");
                    }
                });
            }
        }, advertisingImpl);
        YLoggers.sdkConfiguration(log, Consts.SDK_APPLOVIN, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.TRUE);
        return Futures.successful("max");
    }

    @NonNull
    public static IAdvertising createRVManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, boolean z, GluEventBus gluEventBus) {
        Map<String, Object> configDisabled = ConfigUtil.configDisabled(map);
        if (ConfigUtil.getBoolean(configDisabled, "max")) {
            YLoggers.sdkConfiguration(log, "max", "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
            return new DummyAdvertising();
        }
        Map<String, Object> configSdk = ConfigUtil.configSdk(map);
        return new EAMaxManagerProxy(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, callable, Common.mapSSFromConfig(ConfigUtil.getConfigMapVariant(configSdk, "max.rewardedInterstitialPlacementMapping", z, null)), ConfigUtil.getMap(configSdk, "frequency", null), ConfigUtil.getString(configSdk, "max.placementRewardSeparator", ","), ConfigUtil.getMap(configSdk, "max.rewards"), ConfigUtil.shouldSendImpressionData(configDisabled), ConfigUtil.getBoolean(configDisabled, Consts.IS_LOADED_IGNORE_FREQUENCYCAPPING, false), ConfigUtil.getBoolean(configDisabled, Consts.GLOBAL_FREQUENCY_CAPPING, false), ConfigUtil.getBoolean(configSdk, "debug.all", false), gluEventBus);
    }

    @NonNull
    public static IAdvertising createInterstitialManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, boolean z, GluEventBus gluEventBus) {
        Map<String, Object> configDisabled = ConfigUtil.configDisabled(map);
        if (ConfigUtil.getBoolean(configDisabled, "max")) {
            YLoggers.sdkConfiguration(log, "max", "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
            return new DummyAdvertising();
        }
        Map<String, Object> configSdk = ConfigUtil.configSdk(map);
        return new EAMaxManagerProxy("interstitial", callable, Common.mapSSFromConfig(ConfigUtil.getConfigMapVariant(configSdk, "max.interstitialPlacementMapping", z, null)), ConfigUtil.getMap(configSdk, "frequency", null), ConfigUtil.shouldSendImpressionData(configDisabled), ConfigUtil.getBoolean(configDisabled, Consts.IS_LOADED_IGNORE_FREQUENCYCAPPING, false), ConfigUtil.getBoolean(configSdk, "debug.all", false), gluEventBus);
    }

    private static String getAdapterClassName(String str) {
        return mAdapterNames.get(str);
    }
}