Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/mbridge/msdk/newreward/function/common/DatabaseUtils.java

@@ -0,0 +1,75 @@
+package com.mbridge.msdk.newreward.function.common;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import com.mbridge.msdk.MBridgeConstans;
+import com.mbridge.msdk.foundation.tools.af;
+
+/* loaded from: classes4.dex */
+public final class DatabaseUtils {
+    private DatabaseUtils() {
+    }
+
+    public static boolean isDatabaseAvailable(SQLiteDatabase sQLiteDatabase) {
+        if (sQLiteDatabase == null) {
+            return false;
+        }
+        try {
+            if (sQLiteDatabase.isOpen()) {
+                return !sQLiteDatabase.isReadOnly();
+            }
+            return false;
+        } catch (Exception unused) {
+            return false;
+        }
+    }
+
+    public static void beginTransaction(SQLiteDatabase sQLiteDatabase) {
+        if (isDatabaseAvailable(sQLiteDatabase)) {
+            try {
+                sQLiteDatabase.beginTransaction();
+            } catch (Exception e) {
+                if (MBridgeConstans.DEBUG) {
+                    af.b("DatabaseUtils", "beginTransaction", e);
+                }
+            }
+        }
+    }
+
+    public static void setTransactionSuccessful(SQLiteDatabase sQLiteDatabase) {
+        if (isDatabaseAvailable(sQLiteDatabase)) {
+            try {
+                sQLiteDatabase.setTransactionSuccessful();
+            } catch (Exception e) {
+                if (MBridgeConstans.DEBUG) {
+                    af.b("DatabaseUtils", "setTransactionSuccessful", e);
+                }
+            }
+        }
+    }
+
+    public static void endTransaction(SQLiteDatabase sQLiteDatabase) {
+        if (isDatabaseAvailable(sQLiteDatabase) && sQLiteDatabase.inTransaction()) {
+            try {
+                sQLiteDatabase.endTransaction();
+            } catch (Exception e) {
+                if (MBridgeConstans.DEBUG) {
+                    af.b("DatabaseUtils", "endTransaction", e);
+                }
+            }
+        }
+    }
+
+    public static void closeCursor(Cursor cursor) {
+        if (cursor == null) {
+            return;
+        }
+        try {
+            cursor.close();
+        } catch (Exception e) {
+            if (MBridgeConstans.DEBUG) {
+                af.b("DatabaseUtils", "closeCursor", e);
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/JSONUtils.java

@@ -0,0 +1,17 @@
+package com.mbridge.msdk.newreward.function.common;
+
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class JSONUtils {
+    public static JSONObject parse(String str) {
+        if (str == null) {
+            return null;
+        }
+        try {
+            return new JSONObject(str);
+        } catch (Exception unused) {
+            return null;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/MBridgeCommon.java

@@ -0,0 +1,89 @@
+package com.mbridge.msdk.newreward.function.common;
+
+/* loaded from: classes4.dex */
+public class MBridgeCommon {
+    public static final int AD_SPACE_TYPE_2 = 2;
+    public static final int BIDDING_TYPE_HEADER_BIDDING = 1;
+    public static final int BIDDING_TYPE_WATER_FALL = 0;
+    public static final int DEFAULT_LOAD_TIMEOUT = 60000;
+    public static final int DOWNLOAD_SCENE_LOAD = 0;
+    public static final int DOWNLOAD_SCENE_SHOW = 1;
+    public static final String DYNAMIC_VIEW_TEMPLATE_NAME = "dyview";
+    public static final String DYNAMIC_VIEW_TEMPLATE_VALUE = "102";
+    public static final int LOAD_STATE_LOADING = 1;
+    public static final int LOAD_STATE_LOAD_FINISH = 2;
+    public static final int LOAD_STATE_UN_KNOWN = 0;
+    public static final String PLAYABLE_END_CARD_NAME = "isplayableec";
+    public static final String PLAYABLE_END_CARD_VALUE = "0";
+
+    public static class ADType {
+        public static final int AD_TYPE_INTERSTITIAL_VIDEO = 287;
+        public static final int AD_TYPE_NEW_INTERSTITIAL_VIDEO = 287;
+        public static final int AD_TYPE_REWARD_VIDEO = 94;
+    }
+
+    public static class CampaignState {
+        public static final int STATE_DELETE = 8;
+        public static final int STATE_LOADING = 2;
+        public static final int STATE_LOAD_FAILED_ADN_RETURN_ERROR = 402;
+        public static final int STATE_LOAD_FAILED_ALREADY_INSTALL = 403;
+        public static final int STATE_LOAD_FAILED_CAMPAIGN_REQUEST_ERROR = 401;
+        public static final int STATE_LOAD_FAILED_EXCEPTION = 406;
+        public static final int STATE_LOAD_FAILED_RESOURCE_DOWNLOAD_ERROR = 404;
+        public static final int STATE_LOAD_FAILED_TIMEOUT = 405;
+        public static final int STATE_LOAD_SUCCESS = 3;
+        public static final int STATE_REQUEST_SUCCESS = 1;
+        public static final int STATE_SHOWING = 5;
+        public static final int STATE_SHOW_FAILED = 7;
+        public static final int STATE_SHOW_SUCCESS = 6;
+        public static final int STATE_UN_AVAILABLE = 0;
+    }
+
+    public static class Database {
+        public static final String DATABASE_NAME = "mbridge_sdk_new.db";
+        public static final int DATABASE_VERSION = 2;
+    }
+
+    public static class ResourceCheckRule {
+        public static final int CHECK_RULE_BIG_TEMPLATE = 3;
+        public static final int CHECK_RULE_END_CARD = 2;
+        public static final int CHECK_RULE_TEMPLATE = 1;
+        public static final int CHECK_RULE_VIDEO = 0;
+    }
+
+    public static class ResourceFrom {
+        public static final int FROM_CACHE = 1;
+        public static final int FROM_NETWORK = 2;
+        public static final int FROM_RESUME_FROM_BREAK_POINT = 3;
+        public static final int FROM_UN_KNOWN = 0;
+    }
+
+    public static class ResourceType {
+        public static final int TYPE_END_SCREEN = 8;
+        public static final int TYPE_IMAGE = 6;
+        public static final int TYPE_MRAID = 5;
+        public static final int TYPE_PAUSE = 7;
+        public static final int TYPE_TEMPLATE_BIG = 3;
+        public static final int TYPE_TEMPLATE_ENDCARD = 4;
+        public static final int TYPE_TEMPLATE_VIDEO = 2;
+        public static final int TYPE_VIDEO = 1;
+    }
+
+    public static class SettingConfig {
+        public static final String KEY_SETTING_CONFIG_LOAD_CHECK_INTERVAL = "load_check_interval";
+        public static final String KEY_SETTING_CONFIG_LOAD_CHECK_OPTIMIZED = "load_check_switch";
+        public static final String KEY_SETTING_CONFIG_LOAD_TOKEN_VALIDITY_PERIOD = "load_check_token_validity_period";
+        public static final String KEY_SETTING_CONFIG_RETRY_STRATEGY = "retry_strategy";
+        public static final String KEY_SETTING_CONFIG_RETRY_STRATEGY_CAMPAIGN_REQUEST_INTERVAL = "campaign_request_interval";
+        public static final String KEY_SETTING_CONFIG_RETRY_STRATEGY_CAMPAIGN_REQUEST_MAX = "campaign_request_max";
+        public static final String KEY_SETTING_CONFIG_RETRY_STRATEGY_CAMPAIGN_REQUEST_TIMEOUT = "campaign_request_timeout";
+        public static final String KEY_SETTING_CONFIG_RETRY_STRATEGY_CAMPAIGN_RETRY_TIMEOUT = "campaign_retry_timeout";
+        public static final String KEY_SETTING_CONFIG_RETRY_STRATEGY_DOWNLOAD_RETRY_MAX = "download_retry_max";
+    }
+
+    public static class SharedPreference {
+        public static final String KEY_CAMPAIGN_REQUEST_TIMEOUT = "campaign_request_timeout";
+        public static final String KEY_LOADING_CAPACITY = "loading_capacity";
+        public static final String KEY_VCN = "vcn_%s";
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/MBridgeDailyPlayModel.java

@@ -0,0 +1,56 @@
+package com.mbridge.msdk.newreward.function.common;
+
+import android.text.TextUtils;
+import com.vungle.ads.internal.signals.SignalManager;
+
+/* loaded from: classes4.dex */
+public class MBridgeDailyPlayModel {
+    private final int mAdType;
+    private final String mCountKey;
+    private int mMaxDailyCap = 0;
+    private final String mPlacementID;
+    private final String mTimeKey;
+    private final String mUnitID;
+
+    public void setMaxPlayCount(int i) {
+        this.mMaxDailyCap = i;
+    }
+
+    public MBridgeDailyPlayModel(int i, String str, String str2) {
+        this.mAdType = i;
+        str = TextUtils.isEmpty(str) ? "null" : str;
+        this.mPlacementID = str;
+        str2 = TextUtils.isEmpty(str2) ? "null" : str2;
+        this.mUnitID = str2;
+        String str3 = i + "_" + str + "_" + str2;
+        this.mCountKey = str3 + "_count";
+        this.mTimeKey = str3 + "_time";
+    }
+
+    public void insertDailyCap() {
+        long j = MBridgeSharedPreferenceModel.getInstance().getLong(this.mTimeKey, 0L);
+        int integer = MBridgeSharedPreferenceModel.getInstance().getInteger(this.mCountKey, 0) + 1;
+        if (j == 0 || System.currentTimeMillis() - j > SignalManager.TWENTY_FOUR_HOURS_MILLIS) {
+            MBridgeSharedPreferenceModel.getInstance().putLong(this.mTimeKey, System.currentTimeMillis());
+            MBridgeSharedPreferenceModel.getInstance().putInteger(this.mCountKey, integer);
+        } else {
+            MBridgeSharedPreferenceModel.getInstance().putInteger(this.mCountKey, integer);
+        }
+    }
+
+    public boolean isOverDailyCap() {
+        if (this.mMaxDailyCap <= 0) {
+            return false;
+        }
+        long j = MBridgeSharedPreferenceModel.getInstance().getLong(this.mTimeKey, 0L);
+        if (j == 0) {
+            return false;
+        }
+        if (System.currentTimeMillis() - j <= SignalManager.TWENTY_FOUR_HOURS_MILLIS) {
+            return MBridgeSharedPreferenceModel.getInstance().getInteger(this.mCountKey, 0) >= this.mMaxDailyCap;
+        }
+        MBridgeSharedPreferenceModel.getInstance().putLong(this.mTimeKey, 0L);
+        MBridgeSharedPreferenceModel.getInstance().putInteger(this.mCountKey, 0);
+        return false;
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/MBridgeError.java

@@ -0,0 +1,47 @@
+package com.mbridge.msdk.newreward.function.common;
+
+/* loaded from: classes4.dex */
+public class MBridgeError extends Exception {
+    public static final int ERROR_CODE_DOWNLOAD_DOWNLOAD_TIMEOUT = 4;
+    public static final int ERROR_CODE_DOWNLOAD_NETWORK_ERROR = 2;
+    public static final int ERROR_CODE_DOWNLOAD_NETWORK_TIMEOUT = 3;
+    public static final int ERROR_CODE_DOWNLOAD_NO_CONNECTION = 1;
+    public static final int ERROR_CODE_DOWNLOAD_RESOURCE_URL_ERROR = 5;
+    public static final int ERROR_CODE_DOWNLOAD_UN_ZIP_ERROR = 6;
+    public static final int ERROR_CODE_UN_KNOWN = 0;
+    public static final String ERROR_DOWNLOAD_MESSAGE_NO_CONNECTION = "no connection";
+    public static final String ERROR_MESSAGE_DOWNLOAD_BIG_TEMPLATE_ERROR = "big template error";
+    public static final String ERROR_MESSAGE_DOWNLOAD_DOWNLOAD_TIMEOUT = "download timeout";
+    public static final String ERROR_MESSAGE_DOWNLOAD_EC_TEMPLATE_ERROR = "ec template error";
+    public static final String ERROR_MESSAGE_DOWNLOAD_NETWORK_ERROR = "network error";
+    public static final String ERROR_MESSAGE_DOWNLOAD_NETWORK_TIMEOUT = "network timeout";
+    public static final String ERROR_MESSAGE_DOWNLOAD_RESOURCE_URL_ERROR = "resource url error";
+    public static final String ERROR_MESSAGE_DOWNLOAD_UN_ZIP_ERROR = "unzip error";
+    public static final String ERROR_MESSAGE_DOWNLOAD_VIDEO_ERROR = "video error";
+    public static final String ERROR_MESSAGE_DOWNLOAD_VIDEO_TEMPLATE_ERROR = "video template error";
+    public static final String ERROR_MESSAGE_UN_KNOWN = "unknown error";
+    private final int errorCode;
+    private final String errorMessage;
+    private Exception exception;
+
+    public int getErrorCode() {
+        return this.errorCode;
+    }
+
+    public String getErrorMessage() {
+        return this.errorMessage;
+    }
+
+    public Exception getException() {
+        return this.exception;
+    }
+
+    public void setException(Exception exc) {
+        this.exception = exc;
+    }
+
+    public MBridgeError(int i, String str) {
+        this.errorCode = i;
+        this.errorMessage = str;
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/MBridgeGlobalCommon.java

@@ -0,0 +1,171 @@
+package com.mbridge.msdk.newreward.function.common;
+
+import android.content.Context;
+import android.text.TextUtils;
+import com.ironsource.v8;
+import com.mbridge.msdk.MBridgeConstans;
+import com.mbridge.msdk.foundation.controller.c;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.foundation.tools.af;
+import com.mbridge.msdk.foundation.tools.ak;
+import com.mbridge.msdk.foundation.tools.an;
+import com.mbridge.msdk.newreward.function.c.a.a;
+import com.mbridge.msdk.newreward.function.c.a.b;
+import com.mbridge.msdk.newreward.function.c.c.d;
+import com.mbridge.msdk.newreward.function.c.c.n;
+import com.mbridge.msdk.video.bt.module.b.h;
+import java.net.URLEncoder;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class MBridgeGlobalCommon {
+    public static String SESSION_ID = "";
+    public static Map<String, h> showRewardListenerMap = new HashMap();
+
+    public static void setAlertDialogText(String str, String str2, String str3, String str4, String str5) {
+        Context c = c.m().c();
+        if (!TextUtils.isEmpty(str2)) {
+            an.b(c, "MBridge_ConfirmTitle" + str, str2.trim());
+        }
+        if (!TextUtils.isEmpty(str3)) {
+            an.b(c, "MBridge_ConfirmContent" + str, str3.trim());
+        }
+        if (!TextUtils.isEmpty(str5)) {
+            an.b(c, "MBridge_CancelText" + str, str5.trim());
+        }
+        if (TextUtils.isEmpty(str4)) {
+            return;
+        }
+        an.b(c, "MBridge_ConfirmText" + str, str4.trim());
+    }
+
+    public static void handlerCampaigns(String str, b bVar, List<CampaignEx> list, List<a> list2) {
+        if (bVar == null || list == null || list2 == null) {
+            return;
+        }
+        for (CampaignEx campaignEx : list) {
+            try {
+                campaignEx.setRequestId(bVar.f());
+                campaignEx.setLocalRequestId(str);
+                campaignEx.setCampaignUnitId(bVar.e());
+                a aVar = new a(bVar);
+                aVar.c(campaignEx.getRequestIdNotice());
+                aVar.b(campaignEx.getAppName());
+                aVar.a(campaignEx.getId());
+                aVar.a(campaignEx);
+                list2.add(aVar);
+                if (!com.mbridge.msdk.foundation.same.b.a().a("new_bridge_reward_show") && !TextUtils.isEmpty(campaignEx.getCMPTEntryUrl()) && campaignEx.getAdSpaceT() != 2) {
+                    String cMPTEntryUrl = campaignEx.getCMPTEntryUrl();
+                    boolean i = ak.i(cMPTEntryUrl);
+                    bVar.b(!i);
+                    if (!i) {
+                        cMPTEntryUrl = addQueryParameter(cMPTEntryUrl, "dyview", MBridgeCommon.DYNAMIC_VIEW_TEMPLATE_VALUE);
+                    }
+                    campaignEx.setCMPTEntryUrl(cMPTEntryUrl);
+                }
+                if (TextUtils.isEmpty(bVar.B())) {
+                    bVar.h(campaignEx.getCMPTEntryUrl());
+                    bVar.h(campaignEx.getMof_tplid());
+                }
+                long candidateCacheTime = campaignEx.getCandidateCacheTime();
+                if (candidateCacheTime > 0) {
+                    bVar.b((candidateCacheTime * 1000) + System.currentTimeMillis());
+                }
+                bVar.j(campaignEx.getVcn());
+                bVar.k(campaignEx.getTokenRule());
+                CampaignEx.c rewardTemplateMode = campaignEx.getRewardTemplateMode();
+                if (!com.mbridge.msdk.foundation.same.b.a().a("new_bridge_reward_show")) {
+                    if (rewardTemplateMode != null) {
+                        bVar.i(rewardTemplateMode.b());
+                        String e = rewardTemplateMode.e();
+                        if (!TextUtils.isEmpty(e) && campaignEx.getAdSpaceT() != 2) {
+                            boolean i2 = ak.i(e);
+                            aVar.a(!i2);
+                            if (!i2) {
+                                e = addQueryParameter(e, "dyview", MBridgeCommon.DYNAMIC_VIEW_TEMPLATE_VALUE);
+                            }
+                            rewardTemplateMode.b(e);
+                            campaignEx.setRewardTemplateMode(rewardTemplateMode);
+                        }
+                    }
+                    String str2 = campaignEx.getendcard_url();
+                    if (!TextUtils.isEmpty(str2)) {
+                        boolean l = ak.l(str2);
+                        boolean i3 = ak.i(str2);
+                        if (!l && !i3) {
+                            campaignEx.setendcard_url(addQueryParameter(str2, "isplayableec", "0"));
+                        }
+                    }
+                }
+            } catch (Exception e2) {
+                if (MBridgeConstans.DEBUG) {
+                    af.b("MBridgeGlobalCommon", "handlerCampaigns", e2);
+                }
+            }
+        }
+        bVar.b(list);
+        bVar.a(list2);
+    }
+
+    public static String addQueryParameter(String str, String str2, String str3) {
+        if (str != null && !TextUtils.isEmpty(str2) && !TextUtils.isEmpty(str3)) {
+            try {
+                String encode = URLEncoder.encode(str2, "UTF-8");
+                String encode2 = URLEncoder.encode(str3, "UTF-8");
+                StringBuilder sb = new StringBuilder(str);
+                if (str.contains("?")) {
+                    if (!str.endsWith(v8.i.c) && !str.endsWith("?")) {
+                        sb.append(v8.i.c);
+                    }
+                } else {
+                    sb.append("?");
+                }
+                sb.append(encode);
+                sb.append(v8.i.b);
+                sb.append(encode2);
+                return sb.toString();
+            } catch (Exception e) {
+                if (MBridgeConstans.DEBUG) {
+                    af.b("MBridgeGlobalCommon", "addQueryParameter", e);
+                }
+            }
+        }
+        return "";
+    }
+
+    public static String getIsReadyNotReadyReasonType(b bVar) {
+        if (bVar == null) {
+            return "8";
+        }
+        d<?> w = bVar.w();
+        if (w != null && !w.d()) {
+            return "4";
+        }
+        if (!bVar.A()) {
+            return "10";
+        }
+        List<a> u = bVar.u();
+        if (u == null || u.isEmpty()) {
+            return "8";
+        }
+        for (a aVar : u) {
+            if (aVar != null) {
+                n d = aVar.d();
+                if (d != null && !d.d()) {
+                    return "1";
+                }
+                d<?> c = aVar.c();
+                if (c != null && !c.d()) {
+                    return "2";
+                }
+                d<?> f = aVar.f();
+                if (f != null && !f.d()) {
+                    return "6";
+                }
+            }
+        }
+        return "0";
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/MBridgeOffsetManager.java

@@ -0,0 +1,18 @@
+package com.mbridge.msdk.newreward.function.common;
+
+/* loaded from: classes4.dex */
+public class MBridgeOffsetManager {
+    private int offset = 0;
+
+    public void increaseOffset(int i) {
+        this.offset += i;
+    }
+
+    public void resetOffset() {
+        this.offset = 0;
+    }
+
+    public int getOffset() {
+        return Math.max(this.offset, 0);
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/MBridgeSharedPreferenceModel.java

@@ -0,0 +1,221 @@
+package com.mbridge.msdk.newreward.function.common;
+
+import android.text.TextUtils;
+import com.mbridge.msdk.foundation.same.b.c;
+import com.mbridge.msdk.foundation.same.b.e;
+import com.mbridge.msdk.foundation.tools.FastKV;
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes4.dex */
+public final class MBridgeSharedPreferenceModel {
+    private static final String DEFAULT_NAME = "mbridge_new_config";
+    private volatile FastKV mFastKV;
+    private final String mName;
+    private static final ConcurrentHashMap<String, String> mStringCache = new ConcurrentHashMap<>();
+    private static final ConcurrentHashMap<String, Integer> mIntegerCache = new ConcurrentHashMap<>();
+    private static final ConcurrentHashMap<String, Long> mLongCache = new ConcurrentHashMap<>();
+    private static final Map<String, MBridgeSharedPreferenceModel> mInstanceMap = new HashMap();
+    private static final String mPath = e.a(c.MBRIDGE_700_CONFIG) + File.separator;
+
+    public final void init() {
+    }
+
+    private MBridgeSharedPreferenceModel(String str) {
+        this.mName = str;
+        initFastKV();
+    }
+
+    public static MBridgeSharedPreferenceModel getInstance() {
+        return getInstance("");
+    }
+
+    public static MBridgeSharedPreferenceModel getInstance(String str) {
+        MBridgeSharedPreferenceModel mBridgeSharedPreferenceModel;
+        Map<String, MBridgeSharedPreferenceModel> map = mInstanceMap;
+        synchronized (map) {
+            try {
+                if (TextUtils.isEmpty(str)) {
+                    str = DEFAULT_NAME;
+                }
+                mBridgeSharedPreferenceModel = map.get(str);
+                if (mBridgeSharedPreferenceModel == null) {
+                    mBridgeSharedPreferenceModel = new MBridgeSharedPreferenceModel(str);
+                    map.put(str, mBridgeSharedPreferenceModel);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return mBridgeSharedPreferenceModel;
+    }
+
+    public final void putString(String str, String str2) {
+        if (TextUtils.isEmpty(str) || str2 == null) {
+            return;
+        }
+        ConcurrentHashMap<String, String> concurrentHashMap = mStringCache;
+        if (concurrentHashMap.containsKey(str)) {
+            if (TextUtils.equals(concurrentHashMap.get(str), str2)) {
+                return;
+            }
+            putStringValue(str, str2);
+            return;
+        }
+        putStringValue(str, str2);
+    }
+
+    public final String getString(String str, String str2) {
+        if (TextUtils.isEmpty(str)) {
+            return str2;
+        }
+        ConcurrentHashMap<String, String> concurrentHashMap = mStringCache;
+        if (concurrentHashMap.containsKey(str)) {
+            return concurrentHashMap.get(str);
+        }
+        return getStringValue(str, str2);
+    }
+
+    public final void putLong(String str, long j) {
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        ConcurrentHashMap<String, Long> concurrentHashMap = mLongCache;
+        if (concurrentHashMap.containsKey(str)) {
+            Long l = concurrentHashMap.get(str);
+            if (l == null || l.longValue() != j) {
+                putLongValue(str, j);
+                return;
+            }
+            return;
+        }
+        putLongValue(str, j);
+    }
+
+    public final long getLong(String str, long j) {
+        Long l;
+        if (TextUtils.isEmpty(str)) {
+            return j;
+        }
+        ConcurrentHashMap<String, Long> concurrentHashMap = mLongCache;
+        if (concurrentHashMap.containsKey(str) && (l = concurrentHashMap.get(str)) != null) {
+            return l.longValue();
+        }
+        return getLongValue(str, j);
+    }
+
+    private long getLongValue(String str, long j) {
+        if (this.mFastKV == null) {
+            initFastKV();
+        }
+        try {
+            long j2 = this.mFastKV.getLong(str, j);
+            mLongCache.put(str, Long.valueOf(j2));
+            return j2;
+        } catch (Exception unused) {
+            return j;
+        }
+    }
+
+    private void putLongValue(String str, long j) {
+        try {
+            mLongCache.put(str, Long.valueOf(j));
+        } catch (Exception unused) {
+        }
+        try {
+            this.mFastKV.putLong(str, j);
+        } catch (Exception unused2) {
+        }
+    }
+
+    public final void putInteger(String str, int i) {
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        ConcurrentHashMap<String, Integer> concurrentHashMap = mIntegerCache;
+        if (concurrentHashMap.containsKey(str)) {
+            Integer num = concurrentHashMap.get(str);
+            if (num == null || num.intValue() != i) {
+                putIntegerValue(str, i);
+                return;
+            }
+            return;
+        }
+        putIntegerValue(str, i);
+    }
+
+    public final int getInteger(String str, int i) {
+        Integer num;
+        if (TextUtils.isEmpty(str)) {
+            return i;
+        }
+        ConcurrentHashMap<String, Integer> concurrentHashMap = mIntegerCache;
+        if (concurrentHashMap.containsKey(str) && (num = concurrentHashMap.get(str)) != null) {
+            return num.intValue();
+        }
+        return getIntegerValue(str, i);
+    }
+
+    private int getIntegerValue(String str, int i) {
+        if (this.mFastKV == null) {
+            initFastKV();
+        }
+        try {
+            int i2 = this.mFastKV.getInt(str, i);
+            mIntegerCache.put(str, Integer.valueOf(i2));
+            return i2;
+        } catch (Exception unused) {
+            return i;
+        }
+    }
+
+    private void putIntegerValue(String str, int i) {
+        try {
+            mIntegerCache.put(str, Integer.valueOf(i));
+        } catch (Exception unused) {
+        }
+        try {
+            this.mFastKV.putInt(str, i);
+        } catch (Exception unused2) {
+        }
+    }
+
+    private String getStringValue(String str, String str2) {
+        if (this.mFastKV == null) {
+            initFastKV();
+        }
+        String string = this.mFastKV.getString(str, str2);
+        if (string != null) {
+            mStringCache.put(str, string);
+        }
+        return string;
+    }
+
+    private void putStringValue(String str, String str2) {
+        try {
+            mStringCache.put(str, str2);
+            this.mFastKV.putString(str, str2);
+        } catch (Exception unused) {
+        }
+    }
+
+    public final void clear() {
+        mStringCache.clear();
+        mIntegerCache.clear();
+        mLongCache.clear();
+        if (this.mFastKV != null) {
+            this.mFastKV.clear();
+        }
+    }
+
+    private void initFastKV() {
+        if (this.mFastKV == null) {
+            try {
+                this.mFastKV = new FastKV.Builder(mPath, this.mName).build();
+            } catch (Exception unused) {
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/MBridgeTaskManager.java

@@ -0,0 +1,124 @@
+package com.mbridge.msdk.newreward.function.common;
+
+import android.os.Handler;
+import android.os.HandlerThread;
+import com.mbridge.msdk.MBridgeConstans;
+import com.mbridge.msdk.foundation.tools.af;
+import java.util.concurrent.Executor;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+public class MBridgeTaskManager {
+    private static final int CAMPAIGN_TABLE_THREAD_POOL_CORE_SIZE = 1;
+    private static final int CAMPAIGN_TABLE_THREAD_POOL_MAX_SIZE = 1;
+    private static final String TAG = "MBridgeTaskManager";
+    private static volatile ThreadPoolExecutor campaignTableExecutor;
+    private static volatile ThreadPoolExecutor commonExecutor;
+    private static volatile Handler directorHandler;
+
+    private MBridgeTaskManager() {
+    }
+
+    public static void commonExecute(Runnable runnable) {
+        getCommonExecutor().execute(new TaskWrapper(runnable));
+    }
+
+    public static void campaignTableExecute(Runnable runnable) {
+        getCampaignTableExecutor().execute(new TaskWrapper(runnable));
+    }
+
+    public static void directorExecute(Runnable runnable, long j) {
+        getDirectorHandler().postDelayed(new TaskWrapper(runnable), j);
+    }
+
+    private static Handler getDirectorHandler() {
+        if (directorHandler != null) {
+            return directorHandler;
+        }
+        synchronized (MBridgeTaskManager.class) {
+            try {
+                if (directorHandler == null) {
+                    HandlerThread handlerThread = new HandlerThread("mb_director_thread");
+                    handlerThread.start();
+                    directorHandler = new Handler(handlerThread.getLooper());
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return directorHandler;
+    }
+
+    private static Executor getCommonExecutor() {
+        if (commonExecutor != null) {
+            return commonExecutor;
+        }
+        synchronized (MBridgeTaskManager.class) {
+            try {
+                if (commonExecutor == null) {
+                    commonExecutor = new ThreadPoolExecutor(10, 10, 100L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), new ThreadFactory() { // from class: com.mbridge.msdk.newreward.function.common.MBridgeTaskManager.1
+                        @Override // java.util.concurrent.ThreadFactory
+                        public Thread newThread(Runnable runnable) {
+                            Thread thread = new Thread(runnable);
+                            thread.setName("MBridgeCommonTask");
+                            return thread;
+                        }
+                    });
+                    commonExecutor.allowCoreThreadTimeOut(true);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return commonExecutor;
+    }
+
+    private static Executor getCampaignTableExecutor() {
+        if (campaignTableExecutor != null) {
+            return campaignTableExecutor;
+        }
+        synchronized (MBridgeTaskManager.class) {
+            try {
+                if (campaignTableExecutor == null) {
+                    campaignTableExecutor = new ThreadPoolExecutor(1, 1, 10L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), new ThreadFactory() { // from class: com.mbridge.msdk.newreward.function.common.MBridgeTaskManager.2
+                        @Override // java.util.concurrent.ThreadFactory
+                        public Thread newThread(Runnable runnable) {
+                            Thread thread = new Thread(runnable);
+                            thread.setName("MBridgeCampaignTableTask");
+                            return thread;
+                        }
+                    }, new ThreadPoolExecutor.DiscardPolicy());
+                    campaignTableExecutor.allowCoreThreadTimeOut(true);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return campaignTableExecutor;
+    }
+
+    public static final class TaskWrapper implements Runnable {
+        private final Runnable runnable;
+
+        public TaskWrapper(Runnable runnable) {
+            this.runnable = runnable;
+        }
+
+        @Override // java.lang.Runnable
+        public final void run() {
+            Runnable runnable = this.runnable;
+            if (runnable != null) {
+                try {
+                    runnable.run();
+                } catch (Throwable th) {
+                    if (MBridgeConstans.DEBUG) {
+                        af.b(MBridgeTaskManager.TAG, "TaskWrapper", th);
+                    }
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/newreward/function/common/VolleyErrorUtils.java

@@ -0,0 +1,51 @@
+package com.mbridge.msdk.newreward.function.common;
+
+import com.mbridge.msdk.newreward.function.c.b.b;
+import com.mbridge.msdk.tracker.network.ad;
+
+/* loaded from: classes4.dex */
+public class VolleyErrorUtils {
+    public static b parseVolleyError(ad adVar) {
+        b bVar = new b(0);
+        bVar.b("Network unknown error");
+        if (adVar == null) {
+            return bVar;
+        }
+        int a = adVar.a();
+        if (a == 1) {
+            adVar.a("Network error,please check state code " + adVar.b());
+            bVar = new b(1);
+        } else if (a == 7) {
+            adVar.a("The server returns an exception state code " + adVar.b());
+            bVar = new b(2);
+        } else if (a == 2) {
+            adVar.a("unSupportEncodingException");
+            bVar = new b(8);
+        } else if (a == 8) {
+            adVar.a("Network error,timeout exception");
+            bVar = new b(4);
+        } else if (a == 3) {
+            adVar.a("Network error,I/O exception");
+            bVar = new b(3);
+        } else if (a == 4) {
+            adVar.a(880041);
+            adVar.a("Network error,UnknownHostException");
+            bVar = new b(5);
+        } else if (a == 6) {
+            adVar.a("Network error,I/O exception response null");
+            bVar = new b(7);
+        } else if (a == 5) {
+            adVar.a("Network error,I/O exception");
+            bVar = new b(6);
+        } else if (a == 0) {
+            adVar.a("Network error,I/O exception");
+            bVar = new b(0);
+        } else if (a == 9) {
+            adVar.a("Network unknown error");
+            bVar = new b(1);
+        }
+        bVar.a(adVar);
+        bVar.b(adVar.getMessage());
+        return bVar;
+    }
+}