package csdk.gluads;

import android.app.Activity;
import android.content.Context;
import android.os.Build;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.webkit.ProxyConfig;
import com.facebook.share.internal.ShareConstants;
import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
import com.glu.plugins.gluanalytics.AnalyticsData;
import com.ironsource.b4;
import com.mbridge.msdk.foundation.same.report.i;
import com.tapjoy.TJConnectListener;
import com.tapjoy.TJPrivacyPolicy;
import com.tapjoy.TJStatus;
import com.tapjoy.Tapjoy;
import com.tapjoy.TapjoyConnectFlag;
import csdk.gluads.eventbus.ConfigGetterEventHandler;
import csdk.gluads.eventbus.GluAdsEventHandler;
import csdk.gluads.eventbus.GluEventBus;
import csdk.gluads.impl.AdvertisingImpl;
import csdk.gluads.impl.AdvertisingProxy;
import csdk.gluads.impl.DisabledException;
import csdk.gluads.impl.DummyAdvertising;
import csdk.gluads.impl.IllegalConfigurationException;
import csdk.gluads.impl.QueuingAdvertising;
import csdk.gluads.impl.SuppressionRulesProxy;
import csdk.gluads.ironsource.EAIronSource;
import csdk.gluads.max.EAMax;
import csdk.gluads.tapjoy.TapjoyConnectState;
import csdk.gluads.tapjoy.TapjoyOfferWallManager;
import csdk.gluads.util.AdvertisingUtil;
import csdk.gluads.util.Common;
import csdk.gluads.util.ConfigUtil;
import csdk.gluads.util.DeviceUtil;
import csdk.gluads.util.Futures;
import csdk.gluads.util.IAction1;
import csdk.gluads.util.IAction2;
import csdk.gluads.util.JsonUtil;
import csdk.gluads.util.broadcastmanager.DummyBroadcastManger;
import csdk.gluads.util.broadcastmanager.GluBroadcastManager;
import csdk.gluads.util.log.YLogger;
import csdk.gluads.util.log.YLoggerFactory;
import csdk.gluads.util.log.YLoggers;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Hashtable;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import org.json.JSONException;

/* loaded from: classes4.dex */
public class GluAdsFactory {
    private static final String CONSENT_NO = "0";
    private static final String CONSENT_YES = "1";
    private List<AdvertisingProxy> mProxies = null;
    private final YLogger log = YLoggerFactory.getLogger(getClass());

    @Nullable
    private static Map<String, Object> configSdk(@NonNull Map<String, Object> map) {
        return ConfigUtil.configSdk(map);
    }

    @Nullable
    private static Map<String, Object> configComponents(@NonNull Map<String, Object> map) {
        return ConfigUtil.configComponents(map);
    }

    @Nullable
    public static Map<String, Object> configDisabled(@NonNull Map<String, Object> map) {
        return ConfigUtil.configDisabled(map);
    }

    @NonNull
    public static Future<?> disabledFuture() {
        return Futures.failed(new DisabledException());
    }

    private static boolean isComponentDisabled(@NonNull Map<String, Object> map, @NonNull String str, @NonNull String str2) {
        String str3;
        StringBuilder sb = new StringBuilder();
        sb.append(str);
        if (str2 == null || str2.length() <= 0) {
            str3 = "";
        } else {
            str3 = str2.substring(0, 1).toUpperCase(Locale.US) + str2.substring(1);
        }
        sb.append(str3);
        String sb2 = sb.toString();
        Map<String, Object> configDisabled = configDisabled(map);
        return ConfigUtil.getBoolean(configDisabled, str) || ConfigUtil.getBoolean(configDisabled, sb2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void putIfNotNull(Map<String, IAdvertising> map, String str, IAdvertising iAdvertising) {
        if (iAdvertising != null) {
            map.put(str, iAdvertising);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static List<AdvertisingProxy> createProxies(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @NonNull Long l) {
        return Arrays.asList(new SuppressionRulesProxy(callable, map, l.longValue()));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static IAdvertising wireProxies(IAdvertising iAdvertising, List<AdvertisingProxy> list) {
        int size = list.size() - 1;
        while (size >= 0) {
            AdvertisingProxy advertisingProxy = list.get(size);
            advertisingProxy.init(iAdvertising);
            size--;
            iAdvertising = advertisingProxy;
        }
        return iAdvertising;
    }

    private static GluEventBus eventBus(Map<String, Object> map) {
        return ConfigUtil.getBoolean(map, "csdk.gluAds.disabled.eventBus", false) ? GluEventBus.DISCONNECTED : GluEventBus.SHARED;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static List<String> componentTypes() {
        ArrayList arrayList = new ArrayList();
        arrayList.add(Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL);
        arrayList.add("interstitial");
        arrayList.add(Consts.ADVERTISEMENT_TYPE_OFFER_WALL);
        arrayList.add("banner");
        return arrayList;
    }

    @NonNull
    public IAdvertising createAdvertising(@NonNull final Callable<Activity> callable, @NonNull String str, @Nullable Map<String, Object> map) {
        YLoggers.sdkVersion(this.log, Consts.SDK_GLU_ADS, BuildConfig.VERSION_NAME);
        Common.require(callable != null, "activityGetter can't be null.");
        Common.require(str != null, "jsonConfig can't be null.");
        this.mProxies = null;
        final long currentTimeMillis = System.currentTimeMillis();
        final Map shallowClone = Common.shallowClone(map);
        final QueuingAdvertising queuingAdvertising = new QueuingAdvertising();
        IAction2<String, String> iAction2 = new IAction2<String, String>() { // from class: csdk.gluads.GluAdsFactory.1
            @Override // csdk.gluads.util.IAction2
            public void apply(final String str2, String str3) {
                YLogger yLogger = GluAdsFactory.this.log;
                Object[] objArr = new Object[4];
                objArr[0] = "sdk";
                objArr[1] = Consts.SDK_GLU_ADS;
                objArr[2] = ShareConstants.FEED_SOURCE_PARAM;
                objArr[3] = str3 != null ? str3.toUpperCase(Locale.US) : null;
                yLogger.d("CONFIG.RECONFIGURE", objArr);
                new Thread() { // from class: csdk.gluads.GluAdsFactory.1.1
                    @Override // java.lang.Thread, java.lang.Runnable
                    public void run() {
                        try {
                            Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str2);
                            AnonymousClass1 anonymousClass1 = AnonymousClass1.this;
                            GluAdsFactory.this.doCreateQueuingAdvertising(queuingAdvertising, callable, parseJsonObject, shallowClone, currentTimeMillis);
                        } catch (JSONException e) {
                            throw Common.propagate(e);
                        }
                    }
                }.start();
            }
        };
        try {
            final Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str);
            String json = JsonUtil.toJson(parseJsonObject);
            boolean z = ConfigUtil.getBoolean(parseJsonObject, "csdk.gluAds.disabled.configUpdate", false);
            long j = (long) (ConfigUtil.getDouble(parseJsonObject, "csdk.gluAds.configUpdate.timeoutInSec", 5.0d) * 1000.0d);
            GluEventBus eventBus = eventBus(parseJsonObject);
            if (eventBus.isConnected() && !z) {
                ConfigGetterEventHandler.subscribe(eventBus, GluEventBus.GLOBAL_TOKEN, iAction2, json).requestConfig(j);
            } else {
                this.log.d("CONFIG.RECONFIGURE", "sdk", Consts.SDK_GLU_ADS, ShareConstants.FEED_SOURCE_PARAM, "APP-NO-EB");
                new Thread() { // from class: csdk.gluads.GluAdsFactory.2
                    @Override // java.lang.Thread, java.lang.Runnable
                    public void run() {
                        GluAdsFactory.this.doCreateQueuingAdvertising(queuingAdvertising, callable, parseJsonObject, shallowClone, currentTimeMillis);
                    }
                }.start();
            }
            return queuingAdvertising;
        } catch (JSONException e) {
            throw Common.propagate(e);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doCreateQueuingAdvertising(@NonNull QueuingAdvertising queuingAdvertising, @NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, long j) {
        try {
            queuingAdvertising.delegateTo(doCreateAdvertising(callable, map, map2, j));
        } catch (RuntimeException e) {
            queuingAdvertising.destroy();
            throw Common.propagate(e);
        }
    }

    private IAdvertising doCreateAdvertising(@NonNull final Callable<Activity> callable, @NonNull final Map<String, Object> map, @Nullable final Map<String, Object> map2, final long j) {
        if (ConfigUtil.getBoolean(map, "csdk.disabled.gluAds")) {
            YLoggers.sdkConfiguration(this.log, Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
            return new DummyAdvertising();
        }
        if (!AdvertisingUtil.isAPIEnabled()) {
            YLoggers.sdkConfiguration(this.log, Consts.SDK_GLU_ADS, "DISABLE", "API", Consts.KEY_TAPJOY_USER_ID_VERSION, Integer.valueOf(Build.VERSION.SDK_INT));
            return new DummyAdvertising();
        }
        final Context applicationContext = ((Activity) Common.call(callable)).getApplicationContext();
        final boolean isTablet = DeviceUtil.isTablet(applicationContext);
        final KillSwitch killSwitch = new KillSwitch();
        final DebugSettings debugSettings = new DebugSettings();
        debugSettings.isToastEnabled = ConfigUtil.getBoolean(configSdk(map), "debug.all");
        if (ConfigUtil.getBoolean(configSdk(map), "disabled.callTracking", false)) {
            GluAdsNativeBridge.disableCallTracking();
        }
        final CustomSettings customSettings = new CustomSettings();
        final AdvertisingImpl advertisingImpl = new AdvertisingImpl(GluBroadcastManager.isSupported() ? GluBroadcastManager.getInstance(((Activity) Common.call(callable)).getApplicationContext()) : DummyBroadcastManger.INSTANCE, applicationContext);
        boolean z = !ConfigUtil.getBoolean(configSdk(map), "disabled.privacyFlagsInRTConfig", true);
        final boolean z2 = ConfigUtil.getBoolean(configSdk(map), "disabled.ironSourceAsMediator", false);
        PrivacyStatus privacyStatus = z ? new PrivacyStatus(ConfigUtil.getBoolean(map2, PrivacyStatus.GDPR_APPLIES, false), ConfigUtil.getBoolean(map2, PrivacyStatus.HAS_CONSENT, true), ConfigUtil.getBoolean(map2, PrivacyStatus.CCPA_APPLIES, false), ConfigUtil.getBoolean(map2, PrivacyStatus.CCPA_OPT_OUT, false), ConfigUtil.getBoolean(map2, PrivacyStatus.UNDER_AGE_USER, false), ConfigUtil.getBoolean(map2, PrivacyStatus.TEEN_USER, false)) : null;
        final LoadingScreen loadingScreen = new LoadingScreen();
        boolean z3 = !ConfigUtil.getBoolean(configSdk(map), "disabled.offerWallLoadingIndicator", false);
        if (z3) {
            Common.runOnUIThread(new FutureTask(new Callable<Object>() { // from class: csdk.gluads.GluAdsFactory.3
                @Override // java.util.concurrent.Callable
                public Object call() throws Exception {
                    try {
                        loadingScreen.initialize(callable);
                        return null;
                    } catch (Throwable th) {
                        YLoggers.sdkConfigurationError(GluAdsFactory.this.log, Consts.ADVERTISEMENT_TYPE_OFFER_WALL, "l", Consts.SDK_GLU_ADS, "e", th);
                        throw th;
                    }
                }
            }));
        }
        boolean z4 = z3 && !ConfigUtil.getBoolean(configSdk(map), "disabled.inAppMessageAdLoadingIndicator", false);
        final Map<String, Object> configComponents = configComponents(map);
        PrivacyStatus privacyStatus2 = privacyStatus;
        IAction1<PrivacyStatus> iAction1 = new IAction1<PrivacyStatus>() { // from class: csdk.gluads.GluAdsFactory.4
            /* JADX WARN: Code restructure failed: missing block: B:19:0x0046, code lost:
            
                if (r26.underAgeUser == false) goto L19;
             */
            /* JADX WARN: Code restructure failed: missing block: B:21:0x004a, code lost:
            
                if (r26.teenUser != false) goto L22;
             */
            /* JADX WARN: Code restructure failed: missing block: B:47:0x004c, code lost:
            
                r3 = true;
             */
            @Override // csdk.gluads.util.IAction1
            /*
                Code decompiled incorrectly, please refer to instructions dump.
                To view partially-correct add '--show-bad-code' argument
            */
            public void apply(csdk.gluads.PrivacyStatus r26) {
                /*
                    Method dump skipped, instructions count: 575
                    To view this dump add '--comments-level debug' option
                */
                throw new UnsupportedOperationException("Method not decompiled: csdk.gluads.GluAdsFactory.AnonymousClass4.apply(csdk.gluads.PrivacyStatus):void");
            }
        };
        for (String str : Consts.SDK_ARRAY_AD_NETWORKS) {
            AdvertisingUtil.updatePrivacyInfoAndBroadcast(applicationContext, str, "disabled", iAction1, advertisingImpl);
        }
        Map<String, IAdvertising> createMap = Common.createMap();
        advertisingImpl.setComponentHandlers(createMap);
        YLoggers.sdkConfiguration(this.log, Consts.SDK_GLU_ADS, "handlers", createMap.keySet());
        String string = ConfigUtil.getString(configComponents(map), Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL);
        Map map3 = Collections.EMPTY_MAP;
        final Map<String, Object> map4 = ConfigUtil.getMap(configSdk(map), string + ".rewards", map3);
        final Map<String, Object> map5 = ConfigUtil.getMap(configSdk(map), "frequency", map3);
        final GluAdsEventHandler subscribe = GluAdsEventHandler.subscribe(eventBus(map), GluEventBus.GLOBAL_TOKEN, advertisingImpl);
        if (!ConfigUtil.getBoolean(map, "csdk.gluAds.disabled.autoFetchRulesTagOnShow", false)) {
            subscribe.enableAutoRulesTagFetchOnShow();
        }
        if (!ConfigUtil.getBoolean(map, "csdk.gluAds.disabled.xpv2ImpressionMapping", false)) {
            subscribe.enableImpressionMapping();
        }
        final boolean z5 = z4;
        advertisingImpl.initialize(new Runnable() { // from class: csdk.gluads.GluAdsFactory.5
            @Override // java.lang.Runnable
            public void run() {
                subscribe.onInit(BuildConfig.VERSION_NAME, z5 ? loadingScreen : null);
                subscribe.requestRewardConfig(JsonUtil.toJson(map4));
                subscribe.requestRulesConfig(JsonUtil.toJson(map5), null);
            }
        }, new Runnable() { // from class: csdk.gluads.GluAdsFactory.6
            @Override // java.lang.Runnable
            public void run() {
                subscribe.onDestroy();
            }
        }, subscribe);
        if (z) {
            advertisingImpl.internal_updatePrivacyStatus(privacyStatus2);
        }
        boolean z6 = !ConfigUtil.getBoolean(map, "csdk.gluAds.disabled.setUIDFromRTConf", true);
        String string2 = ConfigUtil.getString(map2, AnalyticsData.S_USER_ID);
        if (z6 && string2 != null) {
            advertisingImpl.setUserIdentifier(string2, null);
        }
        if (this.mProxies == null) {
            this.mProxies = createProxies(callable, map, Long.valueOf(j));
        }
        return wireProxies(advertisingImpl, this.mProxies);
    }

    /* JADX INFO: Access modifiers changed from: private */
    @Nullable
    public IAdvertising createInterstitialOrDie(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @NonNull KillSwitch killSwitch, @NonNull DebugSettings debugSettings, boolean z, @Nullable CustomSettings customSettings, PrivacyStatus privacyStatus) {
        GluEventBus gluEventBus = null;
        if (privacyStatus == null) {
            this.log.d("Can't create Interstitial component since the privacy status is null", new Object[0]);
            return null;
        }
        String string = ConfigUtil.getString(configComponents(map), "interstitial");
        if (TextUtils.isEmpty(string)) {
            YLoggers.componentConfiguration(this.log, "interstitial", "enabled", Boolean.FALSE);
            return null;
        }
        if (TextUtils.equals(string, Consts.SDK_IRONSOURCE) || privacyStatus.underAgeUser || privacyStatus.teenUser) {
            if (isComponentDisabled(map, Consts.SDK_IRONSOURCE, "interstitial")) {
                throw new IllegalConfigurationException("IronSource is disabled.");
            }
            return EAIronSource.createIronSourceInterstitialManager(callable, map, z);
        }
        if (TextUtils.equals(string, "max") || TextUtils.equals(string, Consts.SDK_APPLOVIN) || TextUtils.equals(string, Consts.SDK_MOPUB)) {
            if (isComponentDisabled(map, "max", "interstitial")) {
                throw new IllegalConfigurationException("max is disabled.");
            }
            GluEventBus eventBus = eventBus(map);
            if (eventBus != GluEventBus.DISCONNECTED && !ConfigUtil.getBoolean(configDisabled(map), "rewardedInterstitialCrossPromoBlocked", false)) {
                gluEventBus = eventBus;
            }
            return EAMax.createInterstitialManager(callable, map, z, gluEventBus);
        }
        YLoggers.componentConfiguration(this.log, "interstitial", "l", Consts.SDK_GLU_ADS, i.a, "unsupportedType", Consts.KEY_TAPJOY_USER_ID_VERSION, string);
        return null;
    }

    /* JADX INFO: Access modifiers changed from: private */
    @Nullable
    public IAdvertising createRewardedInterstitialOrDie(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @NonNull KillSwitch killSwitch, @NonNull DebugSettings debugSettings, boolean z, @NonNull CustomSettings customSettings, PrivacyStatus privacyStatus) {
        GluEventBus gluEventBus = null;
        if (privacyStatus == null) {
            this.log.d("Can't create rewarded interstitial component since the privacy status is null", new Object[0]);
            return null;
        }
        String string = ConfigUtil.getString(configComponents(map), Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL);
        if (TextUtils.isEmpty(string)) {
            YLoggers.componentConfiguration(this.log, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, "enabled", Boolean.FALSE);
            return null;
        }
        if (TextUtils.equals(string, Consts.SDK_IRONSOURCE) || privacyStatus.underAgeUser || privacyStatus.teenUser) {
            if (isComponentDisabled(map, Consts.SDK_IRONSOURCE, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
                throw new IllegalConfigurationException("IronSource is disabled.");
            }
            return EAIronSource.createIronSourceRewardedInterstitialManager(callable, map, z);
        }
        if (TextUtils.equals(string, "max") || TextUtils.equals(string, Consts.SDK_APPLOVIN) || TextUtils.equals(string, Consts.SDK_MOPUB)) {
            if (isComponentDisabled(map, "max", Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
                throw new IllegalConfigurationException("MAX is disabled.");
            }
            if (isComponentDisabled(map, Consts.SDK_APPLOVIN, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL)) {
                throw new IllegalConfigurationException("appLovin is disabled.");
            }
            GluEventBus eventBus = eventBus(map);
            if (eventBus != GluEventBus.DISCONNECTED && !ConfigUtil.getBoolean(configDisabled(map), "rewardedInterstitialCrossPromoBlocked", false)) {
                gluEventBus = eventBus;
            }
            return EAMax.createRVManager(callable, map, z, gluEventBus);
        }
        YLoggers.componentConfiguration(this.log, Consts.ADVERTISEMENT_TYPE_REWARDED_INTERSTITIAL, "l", Consts.SDK_GLU_ADS, i.a, "unsupportedType", Consts.KEY_TAPJOY_USER_ID_VERSION, string);
        return null;
    }

    /* JADX INFO: Access modifiers changed from: private */
    @Nullable
    public IAdvertising createOfferWallOrDie(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @NonNull KillSwitch killSwitch, @NonNull DebugSettings debugSettings, boolean z, LoadingScreen loadingScreen, @Nullable CustomSettings customSettings) {
        String string = ConfigUtil.getString(configComponents(map), Consts.ADVERTISEMENT_TYPE_OFFER_WALL);
        if (TextUtils.isEmpty(string) || isComponentDisabled(map, Consts.SDK_TAPJOY, Consts.ADVERTISEMENT_TYPE_OFFER_WALL)) {
            YLoggers.componentConfiguration(this.log, Consts.ADVERTISEMENT_TYPE_OFFER_WALL, "enabled", Boolean.FALSE);
            return null;
        }
        if (TextUtils.equals(string, Consts.SDK_TAPJOY) || TextUtils.equals(string, Consts.SDK_MOPUB) || TextUtils.equals(string, "fyber")) {
            YLoggers.componentConfiguration(this.log, Consts.ADVERTISEMENT_TYPE_OFFER_WALL, "l", Consts.SDK_GLU_ADS, Consts.KEY_TAPJOY_USER_ID_VERSION, string);
            return createTapjoyOfferWallManager(callable, map, map2, loadingScreen, z, customSettings);
        }
        YLoggers.componentConfigurationError(this.log, Consts.ADVERTISEMENT_TYPE_OFFER_WALL, "l", Consts.SDK_GLU_ADS, "e", "unsupportedType", Consts.KEY_TAPJOY_USER_ID_VERSION, string);
        throw new IllegalConfigurationException("Unsupported offerWall type: " + string + Consts.STRING_PERIOD);
    }

    @Nullable
    private IAdvertising createBannerOrDie(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @NonNull KillSwitch killSwitch, @NonNull DebugSettings debugSettings, boolean z, @NonNull CustomSettings customSettings) {
        String string = ConfigUtil.getString(configComponents(map), "banner");
        if (TextUtils.isEmpty(string)) {
            YLoggers.componentConfiguration(this.log, "banner", "enabled", Boolean.FALSE);
            return null;
        }
        YLoggers.componentConfiguration(this.log, "banner", "l", Consts.SDK_GLU_ADS, i.a, "unsupportedType", Consts.KEY_TAPJOY_USER_ID_VERSION, string);
        return null;
    }

    @Nullable
    private IAdvertising createTapjoyOfferWallManager(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @Nullable LoadingScreen loadingScreen, boolean z, @Nullable CustomSettings customSettings) {
        if (!AdvertisingUtil.isAPIEnabled()) {
            return new DummyAdvertising();
        }
        Map<String, Object> configMapVariant = ConfigUtil.getConfigMapVariant(configSdk(map), "tapjoy.offerWallPlacementMapping", z, null);
        if (Common.isEmpty(configMapVariant)) {
            throw new IllegalConfigurationException("Tapjoy does not have offer wall placement mapping.");
        }
        Map<String, String> mapSSFromConfig = Common.mapSSFromConfig(configMapVariant);
        TapjoyOfferWallManager tapjoyOfferWallManager = new TapjoyOfferWallManager(callable, mapSSFromConfig, mapSSFromConfig.remove(ProxyConfig.MATCH_ALL_SCHEMES), loadingScreen);
        customSettings.tapjoyConnectState.setListener(tapjoyOfferWallManager);
        return tapjoyOfferWallManager;
    }

    /* JADX INFO: Access modifiers changed from: private */
    @NonNull
    public Future<?> createTapjoy(@NonNull Callable<Activity> callable, @NonNull Map<String, Object> map, @Nullable Map<String, Object> map2, @NonNull final CustomSettings customSettings, final boolean z, PrivacyStatus privacyStatus, @NonNull AdvertisingImpl advertisingImpl) {
        this.log.d("SDK.VERSION", Consts.SDK_TAPJOY, Tapjoy.getVersion());
        Map<String, Object> configDisabled = configDisabled(map);
        final String string = ConfigUtil.getString(configSdk(map), "tapjoy.sdkKey");
        final Activity activity = (Activity) Common.call(callable);
        customSettings.tapjoyConnectState = new TapjoyConnectState();
        if (ConfigUtil.getBoolean(configDisabled, Consts.SDK_TAPJOY)) {
            YLoggers.sdkConfiguration(this.log, Consts.SDK_TAPJOY, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE);
            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_TAPJOY, "disabled", null, advertisingImpl);
            return disabledFuture();
        }
        if (!AdvertisingUtil.isAPIEnabled()) {
            YLoggers.sdkConfiguration(this.log, Consts.SDK_TAPJOY, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.FALSE, "DISABLE", "API", Consts.KEY_TAPJOY_USER_ID_VERSION, Integer.valueOf(Build.VERSION.SDK_INT));
            AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_TAPJOY, "disabled", null, advertisingImpl);
            return disabledFuture();
        }
        advertisingImpl.updatePrivacyStage(Consts.SDK_TAPJOY, "started");
        AdvertisingUtil.updatePrivacyInfoAndBroadcast(activity, Consts.SDK_TAPJOY, Consts.SDK_PRIVACY_STAGE_ADDED, new IAction1<PrivacyStatus>() { // from class: csdk.gluads.GluAdsFactory.7
            @Override // csdk.gluads.util.IAction1
            public void apply(PrivacyStatus privacyStatus2) {
                TJPrivacyPolicy privacyPolicy = Tapjoy.getPrivacyPolicy();
                if (privacyStatus2.gdprApplies) {
                    GluAdsFactory.this.log.d("GDPR.APPLIES", Consts.SDK_TAPJOY, "No getter provided by the SDK.");
                    GluAdsFactory.this.log.d("ADS.CONSENT", Consts.SDK_TAPJOY, "No getter provided by the SDK.");
                    privacyPolicy.setUserConsent(privacyStatus2.hasConsent ? TJStatus.TRUE : TJStatus.FALSE);
                    privacyPolicy.setSubjectToGDPR(TJStatus.TRUE);
                }
                if (privacyStatus2.ccpaApplies) {
                    privacyPolicy.setUSPrivacy(privacyStatus2.ccpaOptOut ? "1YY-" : "1YN-");
                    if (z) {
                        GluAdsFactory.this.log.d("CCPA", "l", Consts.SDK_TAPJOY, b4.j, "No getter provided by the SDK.");
                    }
                } else {
                    privacyPolicy.setUSPrivacy("1---");
                }
                privacyPolicy.setBelowConsentAge(privacyStatus2.underAgeUser ? TJStatus.TRUE : TJStatus.FALSE);
                Tapjoy.optOutAdvertisingID(activity, privacyStatus2.underAgeUser);
            }
        }, advertisingImpl);
        final Futures.SettableFuture settableFuture = Futures.settable();
        if (TextUtils.isEmpty(string)) {
            settableFuture.set(Consts.SDK_TAPJOY);
        } else {
            final Hashtable hashtable = new Hashtable();
            hashtable.put(TapjoyConnectFlag.ENABLE_LOGGING, Boolean.valueOf(z));
            Common.runOnUIThread(new Runnable() { // from class: csdk.gluads.GluAdsFactory.8
                @Override // java.lang.Runnable
                public void run() {
                    customSettings.tapjoyConnectState.set(true);
                    Tapjoy.connect(activity, string, hashtable, new TJConnectListener() { // from class: csdk.gluads.GluAdsFactory.8.1
                        @Override // com.tapjoy.TJConnectListener, com.tapjoy.TJConnectInterface
                        public void onConnectSuccess() {
                            YLoggers.sdkConfiguration(GluAdsFactory.this.log, Consts.SDK_TAPJOY, "l", Consts.SDK_GLU_ADS, "enabled", Boolean.TRUE);
                            settableFuture.set(Consts.SDK_TAPJOY);
                            Tapjoy.setDebugEnabled(z);
                            Tapjoy.setActivity(activity);
                            Tapjoy.startSession();
                            GluAdsFactory.this.log.d("TAPJOY.CONNECT", "l", Consts.SDK_TAPJOY, InneractiveMediationDefs.GENDER_MALE, Boolean.FALSE);
                            customSettings.tapjoyConnectState.set(false);
                            customSettings.tapjoyConnectState.setListener(null);
                        }

                        @Override // com.tapjoy.TJConnectListener, com.tapjoy.TJConnectInterface
                        public void onConnectFailure(int i, String str) {
                            Exception exc = new Exception("Tapjoy SDK is not initialized. code=" + i + ", m=" + str);
                            YLoggers.sdkConfigurationError(GluAdsFactory.this.log, Consts.SDK_TAPJOY, "l", Consts.SDK_GLU_ADS, "e", exc);
                            settableFuture.setException(exc);
                            GluAdsFactory.this.log.d("TAPJOY.CONNECT", "l", Consts.SDK_TAPJOY, InneractiveMediationDefs.GENDER_MALE, Boolean.FALSE, "tj-c", Integer.valueOf(i), "tj-m", str);
                            customSettings.tapjoyConnectState.set(false);
                            customSettings.tapjoyConnectState.setListener(null);
                        }
                    });
                }
            });
        }
        return settableFuture;
    }
}