Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/com/ironsource/adapters/admob/AdMobAdapter.java

@@ -0,0 +1,376 @@
+package com.ironsource.adapters.admob;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.google.android.gms.ads.AdFormat;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.MobileAds;
+import com.google.android.gms.ads.RequestConfiguration;
+import com.google.android.gms.ads.initialization.AdapterStatus;
+import com.google.android.gms.ads.initialization.InitializationStatus;
+import com.google.android.gms.ads.initialization.OnInitializationCompleteListener;
+import com.google.android.gms.ads.query.QueryInfo;
+import com.google.android.gms.ads.query.QueryInfoGenerationCallback;
+import com.ironsource.adapters.admob.banner.AdMobBannerAdapter;
+import com.ironsource.adapters.admob.interstitial.AdMobInterstitialAdapter;
+import com.ironsource.adapters.admob.nativead.AdMobNativeAdAdapter;
+import com.ironsource.adapters.admob.rewardedvideo.AdMobRewardedVideoAdapter;
+import com.ironsource.environment.ContextProvider;
+import com.ironsource.environment.StringUtils;
+import com.ironsource.mediationsdk.AbstractAdapter;
+import com.ironsource.mediationsdk.INetworkInitCallbackListener;
+import com.ironsource.mediationsdk.IntegrationData;
+import com.ironsource.mediationsdk.IronSource;
+import com.ironsource.mediationsdk.LoadWhileShowSupportState;
+import com.ironsource.mediationsdk.bidding.BiddingDataCallback;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.mediationsdk.metadata.MetaData;
+import com.ironsource.mediationsdk.metadata.MetaDataUtils;
+import com.tapjoy.TapjoyConstants;
+import csdk.gluads.ironsource.EAIronSource;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.json.JSONObject;
+
+/* loaded from: classes2.dex */
+public class AdMobAdapter extends AbstractAdapter {
+    private static final String AD_UNIT_ID = "adUnitId";
+    private static final String EMPTY_STRING = "";
+    private static final String GitHash = "6c36c81";
+    private static final String VERSION = "4.3.45";
+    private static Boolean mCCPAValue = null;
+    private static Boolean mConsent = null;
+    private static String mContentMappingURLValue = "";
+    private static Integer mCoppaValue = null;
+    private static Integer mEuValue = null;
+    private static String mRatingValue = "";
+    private final String INIT_RESPONSE_REQUIRED;
+    private final String NETWORK_ONLY_INIT;
+    private final String PLATFORM_NAME;
+    private final String REQUEST_AGENT;
+    private static List<String> mNeighboringContentMappingURLValue = new ArrayList();
+    private static final HashSet<INetworkInitCallbackListener> initCallbackListeners = new HashSet<>();
+    public static InitState mInitState = InitState.INIT_STATE_NONE;
+    private static final AtomicBoolean mWasInitCalled = new AtomicBoolean(false);
+
+    public interface AdMobMaxContentRating {
+        public static final String ADMOB_MAX_AD_CONTENT_RATING_G = "max_ad_content_rating_g";
+        public static final String ADMOB_MAX_AD_CONTENT_RATING_MA = "max_ad_content_rating_ma";
+        public static final String ADMOB_MAX_AD_CONTENT_RATING_PG = "max_ad_content_rating_pg";
+        public static final String ADMOB_MAX_AD_CONTENT_RATING_T = "max_ad_content_rating_t";
+    }
+
+    public interface AdMobMetaDataFlags {
+        public static final String ADMOB_CONTENT_MAPPING_KEY = "google_content_mapping";
+        public static final String ADMOB_MAX_RATING_KEY = "admob_maxcontentrating";
+        public static final String ADMOB_TFCD_KEY = "admob_tfcd";
+        public static final String ADMOB_TFUA_KEY = "admob_tfua";
+    }
+
+    public enum InitState {
+        INIT_STATE_NONE,
+        INIT_STATE_IN_PROGRESS,
+        INIT_STATE_SUCCESS,
+        INIT_STATE_FAILED
+    }
+
+    public static boolean isNoFillError(int i) {
+        return i == 3 || i == 9;
+    }
+
+    public String getAdUnitIdKey() {
+        return "adUnitId";
+    }
+
+    public InitState getInitState() {
+        return mInitState;
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public String getVersion() {
+        return VERSION;
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public boolean isUsingActivityBeforeImpression(IronSource.AD_UNIT ad_unit) {
+        return false;
+    }
+
+    public static AdMobAdapter startAdapter(String str) {
+        if (EAIronSource.adapterDisabled(AdMobAdapter.class.getName())) {
+            return null;
+        }
+        return new AdMobAdapter(str);
+    }
+
+    private AdMobAdapter(String str) {
+        super(str);
+        this.REQUEST_AGENT = TapjoyConstants.TJC_PLUGIN_UNITY;
+        this.PLATFORM_NAME = TapjoyConstants.TJC_PLUGIN_UNITY;
+        this.NETWORK_ONLY_INIT = "networkOnlyInit";
+        this.INIT_RESPONSE_REQUIRED = "initResponseRequired";
+        IronLog.INTERNAL.verbose();
+        setRewardedVideoAdapter(new AdMobRewardedVideoAdapter(this));
+        setInterstitialAdapter(new AdMobInterstitialAdapter(this));
+        setBannerAdapter(new AdMobBannerAdapter(this));
+        setNativeAdAdapter(new AdMobNativeAdAdapter(this));
+        this.mLWSSupportState = LoadWhileShowSupportState.LOAD_WHILE_SHOW_BY_INSTANCE;
+    }
+
+    public static IntegrationData getIntegrationData(Context context) {
+        return new IntegrationData("AdMob", VERSION);
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public String getCoreSDKVersion() {
+        return getAdapterSDKVersion();
+    }
+
+    public static String getAdapterSDKVersion() {
+        return MobileAds.getVersion().toString();
+    }
+
+    public void initSDK(JSONObject jSONObject) {
+        if (mInitState == InitState.INIT_STATE_NONE || mInitState == InitState.INIT_STATE_IN_PROGRESS) {
+            initCallbackListeners.add(this);
+        }
+        if (mWasInitCalled.compareAndSet(false, true)) {
+            mInitState = InitState.INIT_STATE_IN_PROGRESS;
+            IronLog ironLog = IronLog.ADAPTER_API;
+            ironLog.verbose();
+            if (jSONObject.optBoolean("networkOnlyInit", true)) {
+                ironLog.verbose("disableMediationAdapterInitialization");
+                MobileAds.disableMediationAdapterInitialization(ContextProvider.getInstance().getApplicationContext());
+            }
+            if (jSONObject.optBoolean("initResponseRequired", false)) {
+                ironLog.verbose("init and wait for callback");
+                MobileAds.initialize(ContextProvider.getInstance().getApplicationContext(), new OnInitializationCompleteListener() { // from class: com.ironsource.adapters.admob.AdMobAdapter.1
+                    @Override // com.google.android.gms.ads.initialization.OnInitializationCompleteListener
+                    public void onInitializationComplete(InitializationStatus initializationStatus) {
+                        AdapterStatus adapterStatus = initializationStatus.getAdapterStatusMap().get("com.google.android.gms.ads.MobileAds");
+                        if ((adapterStatus != null ? adapterStatus.getInitializationState() : null) == AdapterStatus.State.READY) {
+                            IronLog.ADAPTER_API.verbose("initializationStatus = READY");
+                            AdMobAdapter.this.initializationSuccess();
+                        } else {
+                            IronLog.ADAPTER_API.verbose("initializationStatus = NOT READY");
+                            AdMobAdapter.this.initializationFailure();
+                        }
+                    }
+                });
+            } else {
+                ironLog.verbose("init without callback");
+                MobileAds.initialize(ContextProvider.getInstance().getApplicationContext());
+                initializationSuccess();
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void initializationSuccess() {
+        mInitState = InitState.INIT_STATE_SUCCESS;
+        Iterator<INetworkInitCallbackListener> it = initCallbackListeners.iterator();
+        while (it.hasNext()) {
+            it.next().onNetworkInitCallbackSuccess();
+        }
+        initCallbackListeners.clear();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void initializationFailure() {
+        mInitState = InitState.INIT_STATE_FAILED;
+        Iterator<INetworkInitCallbackListener> it = initCallbackListeners.iterator();
+        while (it.hasNext()) {
+            it.next().onNetworkInitCallbackFailed("AdMob sdk init failed");
+        }
+        initCallbackListeners.clear();
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public void setConsent(boolean z) {
+        IronLog.ADAPTER_API.verbose("consent = " + z);
+        mConsent = Boolean.valueOf(z);
+    }
+
+    @Override // com.ironsource.mediationsdk.AbstractAdapter
+    public void setMetaData(String str, List<String> list) {
+        if (list.isEmpty()) {
+            return;
+        }
+        if (list.size() > 1 && str.equalsIgnoreCase(AdMobMetaDataFlags.ADMOB_CONTENT_MAPPING_KEY)) {
+            mNeighboringContentMappingURLValue = list;
+            IronLog.ADAPTER_API.verbose("key = " + str + ", values = " + list);
+            return;
+        }
+        String str2 = list.get(0);
+        IronLog.ADAPTER_API.verbose("key = " + str + ", value = " + str2);
+        if (MetaDataUtils.isValidCCPAMetaData(str, str2)) {
+            setCCPAValue(MetaDataUtils.getMetaDataBooleanValue(str2));
+        } else {
+            setAdMobMetaDataValue(StringUtils.toLowerCase(str), StringUtils.toLowerCase(str2));
+        }
+    }
+
+    private void setCCPAValue(boolean z) {
+        IronLog.ADAPTER_API.verbose("value = " + z);
+        mCCPAValue = Boolean.valueOf(z);
+    }
+
+    private void setAdMobMetaDataValue(String str, String str2) {
+        String formatValueForType;
+        if (AdMobMetaDataFlags.ADMOB_TFCD_KEY.equals(str) || AdMobMetaDataFlags.ADMOB_TFUA_KEY.equals(str)) {
+            formatValueForType = MetaDataUtils.formatValueForType(str2, MetaData.MetaDataValueTypes.META_DATA_VALUE_BOOLEAN);
+            if (TextUtils.isEmpty(formatValueForType)) {
+                IronLog.ADAPTER_API.verbose("MetaData value for key " + str + " is invalid " + str2);
+                return;
+            }
+        } else {
+            formatValueForType = str2;
+        }
+        str.hashCode();
+        switch (str) {
+            case "google_content_mapping":
+                mContentMappingURLValue = str2;
+                IronLog.ADAPTER_API.verbose("key = " + str + ", contentMappingValue = " + mContentMappingURLValue);
+                break;
+            case "admob_maxcontentrating":
+                mRatingValue = getAdMobRatingValue(formatValueForType);
+                IronLog.ADAPTER_API.verbose("key = " + str + ", ratingValue = " + mRatingValue);
+                break;
+            case "admob_tfcd":
+                mCoppaValue = Integer.valueOf(getAdMobCoppaValue(formatValueForType));
+                IronLog.ADAPTER_API.verbose("key = " + str + ", coppaValue = " + mCoppaValue);
+                break;
+            case "admob_tfua":
+                mEuValue = Integer.valueOf(getAdMobEuValue(formatValueForType));
+                IronLog.ADAPTER_API.verbose("key = " + str + ", euValue = " + mEuValue);
+                break;
+        }
+        setRequestConfiguration();
+    }
+
+    private int getAdMobCoppaValue(String str) {
+        return MetaDataUtils.getMetaDataBooleanValue(str) ? 1 : 0;
+    }
+
+    private int getAdMobEuValue(String str) {
+        return MetaDataUtils.getMetaDataBooleanValue(str) ? 1 : 0;
+    }
+
+    private String getAdMobRatingValue(String str) {
+        if (TextUtils.isEmpty(str)) {
+            IronLog.INTERNAL.error("The ratingValue is null");
+            return null;
+        }
+        str.hashCode();
+        switch (str) {
+            case "max_ad_content_rating_ma":
+                return RequestConfiguration.MAX_AD_CONTENT_RATING_MA;
+            case "max_ad_content_rating_pg":
+                return RequestConfiguration.MAX_AD_CONTENT_RATING_PG;
+            case "max_ad_content_rating_g":
+                return RequestConfiguration.MAX_AD_CONTENT_RATING_G;
+            case "max_ad_content_rating_t":
+                return RequestConfiguration.MAX_AD_CONTENT_RATING_T;
+            default:
+                IronLog.INTERNAL.error("The ratingValue = " + str + " is undefine");
+                return "";
+        }
+    }
+
+    public AdRequest createAdRequest(JSONObject jSONObject, String str) {
+        AdRequest.Builder builder = new AdRequest.Builder();
+        builder.setRequestAgent(TapjoyConstants.TJC_PLUGIN_UNITY);
+        if (str != null) {
+            builder.setAdString(str);
+        }
+        Bundle bundle = new Bundle();
+        bundle.putString("platform_name", TapjoyConstants.TJC_PLUGIN_UNITY);
+        boolean z = false;
+        if (jSONObject != null) {
+            String optString = jSONObject.optString("requestId", "");
+            z = jSONObject.optBoolean("isHybrid", false);
+            if (!optString.isEmpty()) {
+                bundle.putString("placement_req_id", optString);
+                IronLog.INTERNAL.verbose("adData requestId = " + optString + ", isHybrid = " + z);
+            }
+        } else {
+            IronLog.INTERNAL.verbose("adData is null, using default hybridMode = false");
+        }
+        bundle.putString("is_hybrid_setup", String.valueOf(z));
+        setRequestConfiguration();
+        Boolean bool = mConsent;
+        if (bool != null || mCCPAValue != null) {
+            if (bool != null && !bool.booleanValue()) {
+                IronLog.ADAPTER_API.verbose("mConsent = " + mConsent);
+                bundle.putString("npa", "1");
+            }
+            if (mCCPAValue != null) {
+                IronLog.ADAPTER_API.verbose("mCCPAValue = " + mCCPAValue);
+                bundle.putInt("rdp", mCCPAValue.booleanValue() ? 1 : 0);
+            }
+        }
+        if (!TextUtils.isEmpty(mContentMappingURLValue)) {
+            IronLog.ADAPTER_API.verbose("mContentMappingURLValue = " + mContentMappingURLValue);
+            builder.setContentUrl(mContentMappingURLValue);
+        }
+        if (!mNeighboringContentMappingURLValue.isEmpty()) {
+            IronLog.ADAPTER_API.verbose("mNeighboringContentMappingURLValue = " + mNeighboringContentMappingURLValue);
+            builder.setNeighboringContentUrls(mNeighboringContentMappingURLValue);
+        }
+        builder.addNetworkExtrasBundle(com.google.ads.mediation.admob.AdMobAdapter.class, bundle);
+        return builder.build();
+    }
+
+    private void setRequestConfiguration() {
+        RequestConfiguration.Builder onAdMobLoadRequest = EAIronSource.onAdMobLoadRequest(MobileAds.getRequestConfiguration().toBuilder());
+        Integer num = mCoppaValue;
+        RequestConfiguration build = num != null ? onAdMobLoadRequest.setTagForChildDirectedTreatment(num.intValue()).build() : null;
+        Integer num2 = mEuValue;
+        if (num2 != null) {
+            build = onAdMobLoadRequest.setTagForUnderAgeOfConsent(num2.intValue()).build();
+        }
+        if (!TextUtils.isEmpty(mRatingValue)) {
+            build = onAdMobLoadRequest.setMaxAdContentRating(mRatingValue).build();
+        }
+        if (build != null) {
+            MobileAds.setRequestConfiguration(build);
+        }
+    }
+
+    public void collectBiddingData(final BiddingDataCallback biddingDataCallback, AdFormat adFormat, Bundle bundle) {
+        if (mInitState == InitState.INIT_STATE_NONE) {
+            IronLog.INTERNAL.verbose("returning null as token since init hasn't started");
+            biddingDataCallback.onFailure("returning null as token since init hasn't started - AdMob");
+            return;
+        }
+        Bundle bundle2 = new Bundle();
+        bundle2.putString("query_info_type", "requester_type_2");
+        if (bundle != null) {
+            bundle2.putAll(bundle);
+        }
+        IronLog.ADAPTER_API.verbose(adFormat.toString());
+        QueryInfo.generate(ContextProvider.getInstance().getApplicationContext(), adFormat, new AdRequest.Builder().setRequestAgent(TapjoyConstants.TJC_PLUGIN_UNITY).addNetworkExtrasBundle(com.google.ads.mediation.admob.AdMobAdapter.class, bundle2).build(), new QueryInfoGenerationCallback() { // from class: com.ironsource.adapters.admob.AdMobAdapter.2
+            @Override // com.google.android.gms.ads.query.QueryInfoGenerationCallback
+            public void onSuccess(@NonNull QueryInfo queryInfo) {
+                String query = !TextUtils.isEmpty(queryInfo.getQuery()) ? queryInfo.getQuery() : "";
+                String coreSDKVersion = AdMobAdapter.this.getCoreSDKVersion();
+                IronLog.ADAPTER_API.verbose("token = " + query + ", sdkVersion = " + coreSDKVersion);
+                HashMap hashMap = new HashMap();
+                hashMap.put("token", query);
+                hashMap.put("sdkVersion", coreSDKVersion);
+                biddingDataCallback.onSuccess(hashMap);
+            }
+
+            @Override // com.google.android.gms.ads.query.QueryInfoGenerationCallback
+            public void onFailure(@NonNull String str) {
+                biddingDataCallback.onFailure("failed to receive token - AdMob " + str);
+            }
+        });
+    }
+}