Antivirus Cleaner v1.2.0.0 - VungleTUInitManager.java 源代码

package com.thinkup.network.vungle;

import android.content.Context;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import com.thinkup.core.api.MediationInitCallback;
import com.thinkup.core.api.TUBidRequestInfo;
import com.thinkup.core.api.TUBidRequestInfoListener;
import com.thinkup.core.api.TUInitMediation;
import com.thinkup.core.common.o0.mo;
import com.vungle.ads.InitializationListener;
import com.vungle.ads.VungleAds;
import com.vungle.ads.VungleError;
import com.vungle.ads.VunglePrivacySettings;
import com.vungle.ads.VungleWrapperFramework;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import rf.a;

public class VungleTUInitManager extends TUInitMediation {
    private static volatile VungleTUInitManager m = null;
    private static final String o = "VungleTUInitManager";
    private boolean n;
    private List<MediationInitCallback> o0;
    private String on;
    private final Object oo = new Object();
    private Map<String, WeakReference> om = new ConcurrentHashMap();

    private VungleTUInitManager() {
    }

    public static VungleTUInitManager getInstance() {
        if (m == null) {
            synchronized (VungleTUInitManager.class) {
                try {
                    if (m == null) {
                        m = new VungleTUInitManager();
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
        }
        return m;
    }

    @Override
    public String getAdapterVersion() {
        return "UA_6.4.88.5";
    }

    @Override
    public String getNetworkName() {
        return "Vungle";
    }

    @Override
    public String getNetworkSDKClass() {
        return "com.vungle.ads.VungleAds";
    }

    @Override
    public String getNetworkVersion() {
        return VungleTUConst.getNetworkVersion();
    }

    @Override
    public Map<String, Boolean> getPluginClassStatus() {
        HashMap hashMap = new HashMap();
        Boolean bool = Boolean.FALSE;
        hashMap.put("play-services-ads-identifier-*.aar", bool);
        hashMap.put("play-services-basement-*.aar", bool);
        hashMap.put("okhttp-*.jar", bool);
        hashMap.put("okio-*.jar", bool);
        hashMap.put("kotlinx-serialization-core-jvm-*.jar", bool);
        hashMap.put("kotlinx-serialization-json-jvm-*.jar", bool);
        hashMap.put("protobuf-*.jar", bool);
        try {
            hashMap.put("play-services-ads-identifier-*.aar", Boolean.TRUE);
        } catch (Throwable th) {
            th.printStackTrace();
        }
        try {
            hashMap.put("play-services-basement-*.aar", Boolean.TRUE);
        } catch (Throwable th2) {
            th2.printStackTrace();
        }
        try {
            hashMap.put("okhttp-*.jar", Boolean.TRUE);
        } catch (Throwable th3) {
            th3.printStackTrace();
        }
        try {
            hashMap.put("okio-*.jar", Boolean.TRUE);
        } catch (Throwable th4) {
            th4.printStackTrace();
        }
        try {
            hashMap.put("protobuf-*.jar", Boolean.TRUE);
        } catch (Throwable th5) {
            th5.printStackTrace();
        }
        try {
            hashMap.put("kotlinx-serialization-core-jvm-*.jar", Boolean.TRUE);
        } catch (Throwable th6) {
            th6.printStackTrace();
        }
        try {
            a.a aVar = a.d;
            hashMap.put("kotlinx-serialization-json-jvm-*.jar", Boolean.TRUE);
        } catch (Throwable th7) {
            th7.printStackTrace();
        }
        return hashMap;
    }

    @Override
    public synchronized void initSDK(Context context, Map<String, Object> map, MediationInitCallback mediationInitCallback) {
        synchronized (this.oo) {
            try {
                String obj = map.get("app_id").toString();
                if (map.containsKey(TUInitMediation.KEY_LOCAL)) {
                    this.on = obj;
                } else {
                    String str = this.on;
                    if (str != null && !TextUtils.equals(str, obj)) {
                        checkToSaveInitData(getNetworkName(), map, this.on);
                        this.on = null;
                    }
                }
                if (this.o0 == null) {
                    this.o0 = new ArrayList();
                }
                try {
                    if (((Boolean) map.get(mo.ooo.o0)).booleanValue()) {
                        VunglePrivacySettings.setCCPAStatus(true);
                    }
                } catch (Throwable unused) {
                }
                try {
                    VunglePrivacySettings.setCOPPAStatus(((Boolean) map.get(mo.ooo.oo)).booleanValue());
                } catch (Throwable unused2) {
                }
                if (!VungleAds.isInitialized()) {
                    if (mediationInitCallback != null) {
                        this.o0.add(mediationInitCallback);
                    }
                    if (this.n) {
                        return;
                    }
                    this.n = true;
                    try {
                        VungleAds.setIntegrationName(VungleWrapperFramework.vunglehbs, "7.0.0");
                    } catch (Throwable th) {
                        th.printStackTrace();
                    }
                    VungleAds.init(context.getApplicationContext(), obj, new InitializationListener() {
                        public final void onError(@NonNull VungleError vungleError) {
                            VungleTUInitManager.o(VungleTUInitManager.this, false, vungleError);
                        }

                        public final void onSuccess() {
                            VungleTUInitManager.o(VungleTUInitManager.this, true, (VungleError) null);
                        }
                    });
                } else if (mediationInitCallback != null) {
                    mediationInitCallback.onSuccess();
                }
            } catch (Throwable th2) {
                throw th2;
            }
        }
    }

    @Override
    public boolean setUserDataConsent(Context context, boolean z, boolean z2) {
        VunglePrivacySettings.setGDPRStatus(z, "1.0.0");
        return true;
    }

    private void o(boolean z, VungleError vungleError) {
        synchronized (this.oo) {
            try {
                this.n = false;
                int size = this.o0.size();
                for (int i = 0; i < size; i++) {
                    MediationInitCallback mediationInitCallback = this.o0.get(i);
                    if (mediationInitCallback != null) {
                        if (z) {
                            mediationInitCallback.onSuccess();
                        } else {
                            mediationInitCallback.onFail(vungleError.getCode() + ", " + vungleError.getLocalizedMessage());
                        }
                    }
                }
                this.o0.clear();
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    private void o(String str, WeakReference weakReference) {
        try {
            this.om.put(str, weakReference);
        } catch (Throwable unused) {
        }
    }

    private WeakReference o(String str) {
        return this.om.remove(str);
    }

    public final void o(final Context context, final Map<String, Object> map, final TUBidRequestInfoListener tUBidRequestInfoListener) {
        getInstance().initSDK(context, map, new MediationInitCallback() {
            @Override
            public final void onFail(String str) {
                TUBidRequestInfoListener tUBidRequestInfoListener2 = tUBidRequestInfoListener;
                if (tUBidRequestInfoListener2 != null) {
                    tUBidRequestInfoListener2.onFailed(str);
                }
            }

            @Override
            public final void onSuccess() {
                VungleTUInitManager.this.runOnThreadPool(new Runnable() {
                    @Override
                    public final void run() {
                        AnonymousClass2 anonymousClass2 = AnonymousClass2.this;
                        VungleBidRequestInfo vungleBidRequestInfo = new VungleBidRequestInfo(context, map);
                        if (vungleBidRequestInfo.isValid()) {
                            TUBidRequestInfoListener tUBidRequestInfoListener2 = tUBidRequestInfoListener;
                            if (tUBidRequestInfoListener2 != null) {
                                tUBidRequestInfoListener2.onSuccess(vungleBidRequestInfo);
                                return;
                            }
                            return;
                        }
                        TUBidRequestInfoListener tUBidRequestInfoListener3 = tUBidRequestInfoListener;
                        if (tUBidRequestInfoListener3 != null) {
                            tUBidRequestInfoListener3.onFailed(TUBidRequestInfo.BIDTOKEN_EMPTY_ERROR_TYPE);
                        }
                    }
                });
            }
        });
    }

    public static void o(VungleTUInitManager vungleTUInitManager, boolean z, VungleError vungleError) {
        synchronized (vungleTUInitManager.oo) {
            try {
                vungleTUInitManager.n = false;
                int size = vungleTUInitManager.o0.size();
                for (int i = 0; i < size; i++) {
                    MediationInitCallback mediationInitCallback = vungleTUInitManager.o0.get(i);
                    if (mediationInitCallback != null) {
                        if (z) {
                            mediationInitCallback.onSuccess();
                        } else {
                            mediationInitCallback.onFail(vungleError.getCode() + ", " + vungleError.getLocalizedMessage());
                        }
                    }
                }
                vungleTUInitManager.o0.clear();
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    public synchronized void initSDK(Context context, Map<String, Object> map) {
        initSDK(context, map, null);
    }
}