Utils.java 源代码

package com.applovin.impl.sdk.utils;

import android.R;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.ResolveInfo;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Color;
import android.net.Uri;
import android.os.Build;
import android.os.Looper;
import android.provider.Settings;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Toast;
import androidx.annotation.Keep;
import androidx.annotation.Nullable;
import com.applovin.impl.sdk.AppLovinAdBase;
import com.applovin.impl.sdk.k;
import com.applovin.impl.sdk.u;
import com.applovin.mediation.MaxAd;
import com.applovin.mediation.MaxAdFormat;
import com.applovin.sdk.AppLovinAd;
import com.applovin.sdk.AppLovinAdSize;
import com.applovin.sdk.AppLovinAdType;
import com.applovin.sdk.AppLovinSdk;
import com.applovin.sdk.AppLovinSdkSettings;
import com.applovin.sdk.AppLovinSdkUtils;
import h0.d;
import h0.g;
import h0.h;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.IOException;
import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.net.NetworkInterface;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.zip.GZIPOutputStream;
import n0.c;
import n0.f;
import org.json.JSONObject;

@Keep
public abstract class Utils {
    public static final String MACRO_CLCODE = "{CLCODE}";
    public static final String MACRO_CLICK_X = "{CLICK_X}";
    public static final String MACRO_CLICK_Y = "{CLICK_Y}";
    private static final String MACRO_EVENT_ID = "{EVENT_ID}";
    public static final String MACRO_IS_VIDEO_CLICK = "{IS_VIDEO_CLICK}";
    public static final String MACRO_SCREEN_HEIGHT = "{SCREEN_HEIGHT}";
    public static final String MACRO_SCREEN_WIDTH = "{SCREEN_WIDTH}";
    private static final String PLACEMENT_MACRO = "{PLACEMENT}";
    public static final String PLAY_STORE_PACKAGE_NAME = "com.android.vending";
    public static final String PLAY_STORE_SCHEME = "market";
    public static final String SHOWN_OUT_OF_CONTEXT_MACRO = "{SOC}";
    private static final String TAG = "Utils";
    public static Boolean isExoPlayerEligible;

    static class a implements Comparator<String> {
        a() {
        }

        @Override
        public int compare(String str, String str2) {
            return str.compareToIgnoreCase(str2);
        }
    }

    static class b implements Runnable {

        final Context f7811q;

        final String f7812r;

        b(Context context, String str) {
            this.f7811q = context;
            this.f7812r = str;
        }

        @Override
        public void run() {
            Toast makeText = Toast.makeText(this.f7811q, this.f7812r, 0);
            makeText.setMargin(0.0f, 0.1f);
            makeText.show();
        }
    }

    public static boolean bitMaskContainsFlag(long j6, long j7) {
        if ((j6 & j7) != 0) {
            return true;
        }
        return false;
    }

    public static List<Uri> checkCachedResourcesExist(boolean z6, g gVar, k kVar, Context context) {
        if (gVar instanceof t.a) {
            return Collections.emptyList();
        }
        ArrayList arrayList = new ArrayList();
        for (Uri uri : new ArrayList(gVar.a())) {
            if (!kVar.y().q(uri.getLastPathSegment(), context)) {
                kVar.U0().l(TAG, "Cached HTML asset missing: " + uri);
                arrayList.add(uri);
            }
        }
        if (z6) {
            Uri M0 = gVar.M0();
            if (!kVar.y().q(M0.getLastPathSegment(), context)) {
                kVar.U0().l(TAG, "Cached video missing: " + M0);
                arrayList.add(M0);
            }
        }
        return arrayList;
    }

    public static boolean checkClassExistence(String str) {
        if (TextUtils.isEmpty(str)) {
            return false;
        }
        try {
            Class.forName(str);
            return true;
        } catch (Throwable unused) {
            return false;
        }
    }

    public static boolean checkClassesExistence(List<String> list) {
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            if (checkClassExistence(it.next())) {
                return true;
            }
        }
        return false;
    }

    public static boolean checkExoPlayerEligibility(k kVar) {
        boolean z6;
        if (isExoPlayerEligible == null) {
            int tryToGetExoPlayerVersionCode = tryToGetExoPlayerVersionCode();
            int intValue = ((Integer) kVar.A(j0.b.f23120k2)).intValue();
            if (checkClassExistence("com.google.android.exoplayer2.ui.PlayerView") && tryToGetExoPlayerVersionCode >= ((Integer) kVar.A(j0.b.f23115j2)).intValue() && (intValue < 0 || tryToGetExoPlayerVersionCode <= intValue)) {
                z6 = true;
            } else {
                z6 = false;
            }
            isExoPlayerEligible = Boolean.valueOf(z6);
        }
        return isExoPlayerEligible.booleanValue();
    }

    public static void close(Closeable closeable, k kVar) {
        if (closeable == null) {
            return;
        }
        try {
            closeable.close();
        } catch (Throwable th) {
            if (kVar != null) {
                kVar.U0().h(TAG, "Unable to close stream: " + closeable, th);
            }
        }
    }

    public static void disconnect(HttpURLConnection httpURLConnection, k kVar) {
        if (httpURLConnection == null) {
            return;
        }
        try {
            httpURLConnection.disconnect();
        } catch (Throwable th) {
            if (kVar != null) {
                kVar.U0().h(TAG, "Unable to disconnect connection: " + httpURLConnection, th);
            }
        }
    }

    public static String encodeUrlMap(Map<String, String> map, boolean z6) {
        if (map != null && !map.isEmpty()) {
            StringBuilder sb = new StringBuilder();
            if (z6) {
                TreeMap treeMap = new TreeMap(new a());
                treeMap.putAll(map);
                map = treeMap;
            }
            for (Map.Entry<String, String> entry : map.entrySet()) {
                if (sb.length() > 0) {
                    sb.append("&");
                }
                sb.append((Object) entry.getKey());
                sb.append('=');
                sb.append((Object) entry.getValue());
            }
            return sb.toString();
        }
        return "";
    }

    private static long floatToLong(float f6) {
        return Math.round(f6);
    }

    private static List<Class> generateClassesList(List<String> list, k kVar) {
        if (list == null) {
            return null;
        }
        ArrayList arrayList = new ArrayList(list.size());
        for (String str : list) {
            try {
                arrayList.add(Class.forName(str));
            } catch (ClassNotFoundException unused) {
                kVar.U0().l(TAG, "Failed to create class for name: " + str);
            }
        }
        return arrayList;
    }

    public static int getAlwaysFinishActivitiesSetting(Context context) {
        f.d();
        return Settings.System.getInt(context.getContentResolver(), "always_finish_activities", 0);
    }

    public static String getAndroidOSInfo() {
        try {
            return Build.VERSION.RELEASE + " (" + getAndroidSdkCodename() + " - API " + Build.VERSION.SDK_INT + ")";
        } catch (Throwable th) {
            u.j(TAG, "Unable to get Android OS info", th);
            return "";
        }
    }

    public static String getAndroidSdkCodename() {
        try {
            for (Field field : Build.VERSION_CODES.class.getFields()) {
                if (field.getInt(null) == Build.VERSION.SDK_INT) {
                    return field.getName();
                }
            }
            return "";
        } catch (Throwable th) {
            u.j(TAG, "Unable to get Android SDK codename", th);
            return "";
        }
    }

    public static boolean getBooleanForProbability(int i6) {
        if (i6 <= 0 || i6 > 100 || ((int) (Math.random() * 100.0d)) + 1 > i6) {
            return false;
        }
        return true;
    }

    public static Field getField(Class cls, String str) {
        try {
            return cls.getDeclaredField(str);
        } catch (NoSuchFieldException unused) {
            Class superclass = cls.getSuperclass();
            if (superclass == null) {
                return null;
            }
            return getField(superclass, str);
        }
    }

    @Nullable
    public static Map<String, String> getMetaData(AppLovinSdkSettings appLovinSdkSettings) {
        try {
            Field field = getField(appLovinSdkSettings.getClass(), "metaData");
            if (field != null) {
                field.setAccessible(true);
            }
            return (Map) field.get(appLovinSdkSettings);
        } catch (Throwable unused) {
            return null;
        }
    }

    public static int getOrientation(Context context) {
        Resources resources;
        Configuration configuration;
        if (context != null && (resources = context.getResources()) != null && (configuration = resources.getConfiguration()) != null) {
            return configuration.orientation;
        }
        return 0;
    }

    public static List<k0.a> getPostbacks(String str, JSONObject jSONObject, String str2, String str3, k kVar) {
        return getPostbacks(str, jSONObject, str2, (Map<String, String>) null, str3, kVar);
    }

    public static View getRootView(View view) {
        View rootView;
        if (view == null || (rootView = view.getRootView()) == null) {
            return null;
        }
        View findViewById = rootView.findViewById(R.id.content);
        if (findViewById != null) {
            return findViewById;
        }
        return rootView;
    }

    public static int getRotation(Context context) {
        WindowManager windowManager = (WindowManager) context.getSystemService("window");
        if (windowManager == null) {
            return 0;
        }
        return windowManager.getDefaultDisplay().getRotation();
    }

    public static String getSafedkSdkKey() {
        return getSafedkString("getSdkKey");
    }

    private static String getSafedkString(String str) {
        Class<?> cls;
        try {
            try {
                cls = Class.forName("com.applovin.quality.AppLovinQualityService");
            } catch (Throwable unused) {
                cls = Class.forName("com.safedk.android.SafeDK");
            }
            return (String) cls.getMethod(str, new Class[0]).invoke(null, new Object[0]);
        } catch (Throwable unused2) {
            return "";
        }
    }

    public static String getSafedkVersion() {
        return getSafedkString("getVersion");
    }

    public static long getServerAdjustedUnixTimestampMillis(k kVar) {
        long longValue = ((Long) kVar.A(j0.b.Q3)).longValue();
        long longValue2 = ((Long) kVar.A(j0.b.R3)).longValue();
        long currentTimeMillis = System.currentTimeMillis();
        if (longValue > 0 && longValue2 > 0) {
            return currentTimeMillis + (longValue - longValue2);
        }
        return currentTimeMillis;
    }

    public static String getString(Class cls, String str) {
        try {
            Field field = getField(cls, str);
            field.setAccessible(true);
            return (String) field.get(null);
        } catch (Throwable unused) {
            return null;
        }
    }

    public static String getUserEngagementSdkVersion() {
        try {
            return (String) Class.forName("com.applovin.sdk.userengagement.impl.api.AppLovinUserEngagementSdkImpl").getMethod("getVersion", new Class[0]).invoke(null, new Object[0]);
        } catch (Throwable unused) {
            return "";
        }
    }

    public static int getVideoCompletionPercent(JSONObject jSONObject) {
        int i6 = JsonUtils.getInt(jSONObject, "video_completion_percent", -1);
        if (i6 >= 0 && i6 <= 100) {
            return i6;
        }
        return 95;
    }

    public static d getZone(JSONObject jSONObject, k kVar) {
        return d.b(AppLovinAdSize.fromString(JsonUtils.getString(jSONObject, "ad_size", null)), AppLovinAdType.fromString(JsonUtils.getString(jSONObject, "ad_type", null)), JsonUtils.getString(jSONObject, "zone_id", null));
    }

    public static byte[] gzip(byte[] bArr) throws IOException {
        if (bArr != null && bArr.length != 0) {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(bArr.length);
            GZIPOutputStream gZIPOutputStream = new GZIPOutputStream(byteArrayOutputStream);
            gZIPOutputStream.write(bArr);
            gZIPOutputStream.close();
            return byteArrayOutputStream.toByteArray();
        }
        return null;
    }

    public static boolean hasAndroidCoreJsonLibrary(k kVar) {
        if (f.e()) {
            try {
                JSONObject.wrap(JSONObject.NULL);
                return true;
            } catch (Throwable th) {
                kVar.U0().d(TAG, "Failed to wrap JSONObject with exception", th);
                return false;
            }
        }
        return true;
    }

    public static boolean isAppLovinTestEnvironment(Context context) {
        return c.b(context).d("applovin.sdk.is_test_environment");
    }

    public static boolean isBML(AppLovinAdSize appLovinAdSize) {
        if (appLovinAdSize != AppLovinAdSize.BANNER && appLovinAdSize != AppLovinAdSize.MREC && appLovinAdSize != AppLovinAdSize.LEADER && appLovinAdSize != AppLovinAdSize.CROSS_PROMO) {
            return false;
        }
        return true;
    }

    public static boolean isCurrentProcessInForeground() {
        ActivityManager.RunningAppProcessInfo runningAppProcessInfo = new ActivityManager.RunningAppProcessInfo();
        try {
            ActivityManager.getMyMemoryState(runningAppProcessInfo);
        } catch (Throwable th) {
            u.j(TAG, "Exception thrown while getting memory state.", th);
        }
        int i6 = runningAppProcessInfo.importance;
        if (i6 != 100 && i6 != 200) {
            return false;
        }
        return true;
    }

    public static boolean isDomainWhitelisted(String str, List<String> list) {
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            if (str.startsWith(it.next())) {
                return true;
            }
        }
        return false;
    }

    public static boolean isMainThread() {
        if (Looper.myLooper() == Looper.getMainLooper()) {
            return true;
        }
        return false;
    }

    public static boolean isProguardRulesOmitted() {
        try {
            String str = AppLovinSdk.VERSION;
            return false;
        } catch (ClassNotFoundException unused) {
            return true;
        }
    }

    public static boolean isPubInDebugMode(Context context) {
        if ((context.getApplicationInfo().flags & 2) != 0) {
            return true;
        }
        return false;
    }

    public static boolean isTestApp(Context context) {
        String packageName = context.getPackageName();
        if (!"com.revolverolver.fliptrickster".equals(packageName) && !"com.mindstormstudios.idlemakeover".equals(packageName)) {
            return false;
        }
        return true;
    }

    public static boolean isVPNConnected() {
        try {
            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
            while (networkInterfaces.hasMoreElements()) {
                String displayName = networkInterfaces.nextElement().getDisplayName();
                if (displayName.contains("tun") || displayName.contains("ppp") || displayName.contains("ipsec")) {
                    return true;
                }
            }
            return false;
        } catch (Throwable th) {
            u.j(TAG, "Unable to check Network Interfaces", th);
            return false;
        }
    }

    @Keep
    public static boolean isVerboseLoggingConfigured() {
        Context k6 = k.k();
        if (k6 != null) {
            return c.b(k6).d("applovin.sdk.verbose_logging");
        }
        return false;
    }

    public static boolean isVerboseLoggingEnabled(Context context) {
        if (context == null) {
            context = k.k();
        }
        if (context == null) {
            return false;
        }
        return c.b(context).e("applovin.sdk.verbose_logging", false);
    }

    public static boolean isViewInChildView(View view, View view2) {
        if (view == view2) {
            return true;
        }
        if (view2 instanceof ViewGroup) {
            ViewGroup viewGroup = (ViewGroup) view2;
            for (int i6 = 0; i6 < viewGroup.getChildCount(); i6++) {
                if (isViewInChildView(view, viewGroup.getChildAt(i6))) {
                    return true;
                }
            }
        }
        return false;
    }

    public static boolean isViewInTopActivity(View view, Activity activity) {
        View rootView;
        if (activity != null && view != null) {
            Window window = activity.getWindow();
            if (window != null) {
                rootView = window.getDecorView();
            } else {
                View findViewById = activity.findViewById(R.id.content);
                if (findViewById != null) {
                    rootView = findViewById.getRootView();
                }
            }
            return isViewInChildView(view, rootView);
        }
        return false;
    }

    public static void maybeHandleNoFillResponseForPublisher(String str, MaxAdFormat maxAdFormat, JSONObject jSONObject, k kVar) {
        if (jSONObject.has("no_fill_reason")) {
            u.p("AppLovinSdk", "\n**************************************************\nNO FILL received:\n..ID: \"" + str + "\"\n..FORMAT: \"" + maxAdFormat.getLabel() + "\"\n..SDK KEY: \"" + kVar.S0() + "\"\n..PACKAGE NAME: \"" + kVar.j().getPackageName() + "\"\n..Reason: " + JsonUtils.getObject(jSONObject, "no_fill_reason", new Object()) + "\n**************************************************\n");
        }
    }

    public static AppLovinAd maybeRetrieveNonDummyAd(AppLovinAd appLovinAd, k kVar) {
        if (appLovinAd instanceof h) {
            h hVar = (h) appLovinAd;
            AppLovinAd dequeueAd = kVar.O0().dequeueAd(hVar.getAdZone());
            kVar.U0().g(TAG, "Dequeued ad for dummy ad: " + dequeueAd);
            if (dequeueAd != null) {
                hVar.b(dequeueAd);
                ((AppLovinAdBase) dequeueAd).setDummyAd(hVar);
                return dequeueAd;
            }
            return hVar.a();
        }
        return appLovinAd;
    }

    public static double millisToSeconds(long j6) {
        return j6 / 1000.0d;
    }

    public static boolean objectIsOfType(Object obj, List<String> list, k kVar) {
        if (list == null) {
            return false;
        }
        Iterator<Class> it = generateClassesList(list, kVar).iterator();
        while (it.hasNext()) {
            if (it.next().isInstance(obj)) {
                if (obj instanceof Map) {
                    for (Map.Entry entry : ((Map) obj).entrySet()) {
                        if (!(entry.getKey() instanceof String)) {
                            kVar.U0().g(TAG, "Invalid key type used. Map keys should be of type String.");
                            return false;
                        }
                        if (!objectIsOfType(entry.getValue(), list, kVar)) {
                            return false;
                        }
                    }
                    return true;
                }
                if (obj instanceof List) {
                    Iterator it2 = ((List) obj).iterator();
                    while (it2.hasNext()) {
                        if (!objectIsOfType(it2.next(), list, kVar)) {
                            return false;
                        }
                    }
                    return true;
                }
                return true;
            }
        }
        kVar.U0().g(TAG, "Object '" + obj + "' does not match any of the required types '" + list + "'.");
        return false;
    }

    public static boolean openUri(Context context, Uri uri, k kVar) {
        boolean z6;
        try {
            Intent intent = new Intent("android.intent.action.VIEW", uri);
            if (!(context instanceof Activity)) {
                intent.setFlags(268435456);
            }
            if ("market".equals(intent.getScheme())) {
                intent.setPackage("com.android.vending");
            }
            kVar.W().c();
            context.startActivity(intent);
            z6 = true;
        } catch (Throwable th) {
            kVar.U0().h(TAG, "Unable to open \"" + uri + "\".", th);
            z6 = false;
        }
        if (!z6) {
            kVar.W().e();
        }
        return z6;
    }

    public static long parseColor(String str) {
        if (StringUtils.isValidString(str)) {
            try {
                return Color.parseColor(str);
            } catch (Throwable unused) {
                return Long.MAX_VALUE;
            }
        }
        return Long.MAX_VALUE;
    }

    public static void putObjectForStringIfValid(String str, String str2, Map map) {
        if (!TextUtils.isEmpty(str2)) {
            map.put(str, str2);
        }
    }

    public static void renameKeyInObjectMap(String str, String str2, Map<String, Object> map) {
        if (map.containsKey(str)) {
            map.put(str2, map.get(str));
            map.remove(str);
        }
    }

    public static String replaceCommonMacros(String str) {
        return replaceCommonMacros(false, str);
    }

    public static String retrieveLauncherActivityFullyQualifiedName(Context context) {
        Intent intent = new Intent("android.intent.action.MAIN");
        intent.setPackage(context.getPackageName());
        List<ResolveInfo> queryIntentActivities = context.getPackageManager().queryIntentActivities(intent, 0);
        if (!queryIntentActivities.isEmpty()) {
            return queryIntentActivities.get(0).activityInfo.name;
        }
        return null;
    }

    public static Activity retrieveParentActivity(View view, k kVar) {
        if (view == null) {
            return null;
        }
        int i6 = 0;
        while (i6 < 1000) {
            i6++;
            try {
                Context context = view.getContext();
                if (context instanceof Activity) {
                    return (Activity) context;
                }
                Object parent = view.getParent();
                if (!(parent instanceof View)) {
                    return null;
                }
                view = (View) parent;
            } catch (Throwable th) {
                kVar.U0().h(TAG, "Encountered error while retrieving activity from view", th);
            }
        }
        return null;
    }

    public static Object sanitizeSuperProperty(Object obj, k kVar) {
        int intValue;
        String valueOf;
        if (obj instanceof Map) {
            Map map = (Map) obj;
            HashMap hashMap = new HashMap(map.size());
            for (Map.Entry entry : map.entrySet()) {
                Object key = entry.getKey();
                if (key instanceof String) {
                    valueOf = (String) key;
                } else {
                    valueOf = String.valueOf(key);
                }
                hashMap.put(valueOf, sanitizeSuperProperty(entry.getValue(), kVar));
            }
            return hashMap;
        }
        if (obj instanceof List) {
            List list = (List) obj;
            ArrayList arrayList = new ArrayList(list.size());
            Iterator it = list.iterator();
            while (it.hasNext()) {
                arrayList.add(sanitizeSuperProperty(it.next(), kVar));
            }
            return arrayList;
        }
        if (obj instanceof Date) {
            return String.valueOf(((Date) obj).getTime());
        }
        String valueOf2 = String.valueOf(obj);
        if (obj instanceof String) {
            intValue = ((Integer) kVar.A(j0.b.B0)).intValue();
            if (intValue <= 0 || valueOf2.length() <= intValue) {
                return valueOf2;
            }
        } else if (!(obj instanceof Uri) || (intValue = ((Integer) kVar.A(j0.b.C0)).intValue()) <= 0 || valueOf2.length() <= intValue) {
            return valueOf2;
        }
        return valueOf2.substring(0, intValue);
    }

    public static float secondsToMillis(float f6) {
        return f6 * 1000.0f;
    }

    public static long secondsToMillisLong(float f6) {
        return floatToLong(secondsToMillis(f6));
    }

    public static String shortenKey(String str) {
        if (str != null && str.length() > 4) {
            return str.substring(str.length() - 4);
        }
        return "NOKEY";
    }

    public static void showAlert(String str, String str2, Context context) {
        new AlertDialog.Builder(context).setTitle(str).setMessage(str2).setNegativeButton(R.string.ok, (DialogInterface.OnClickListener) null).create().show();
    }

    public static void showToast(String str, Context context) {
        AppLovinSdkUtils.runOnUiThread(new b(context, str));
    }

    public static Map<String, String> stringifyObjectMap(Map<String, Object> map) {
        HashMap hashMap = new HashMap();
        if (map != null && !map.isEmpty()) {
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                hashMap.put(entry.getKey(), String.valueOf(entry.getValue()));
            }
        }
        return hashMap;
    }

    public static Map<String, String> toUrlSafeMap(Map<String, String> map) {
        HashMap hashMap = new HashMap(map);
        for (String str : hashMap.keySet()) {
            String str2 = (String) hashMap.get(str);
            if (str2 != null) {
                hashMap.put(str, StringUtils.encodeUrlString(str2));
            }
        }
        return hashMap;
    }

    public static int toVersionCode(String str) {
        int i6 = 0;
        for (String str2 : str.replaceAll("-beta", ".").split("\\.")) {
            if (str2.length() > 2) {
                u.p(TAG, "Version number components cannot be longer than two digits -> " + str);
                return i6;
            }
            i6 = (i6 * 100) + Integer.parseInt(str2);
        }
        if (!str.contains("-beta")) {
            return (i6 * 100) + 99;
        }
        return i6;
    }

    public static double tryParseDouble(String str, double d6) {
        try {
            return Double.parseDouble(str);
        } catch (Throwable th) {
            u.j(TAG, "Failed to parse double from String: " + str, th);
            return d6;
        }
    }

    public static int tryToGetExoPlayerVersionCode() {
        try {
            Field field = getField(Class.forName("com.google.android.exoplayer2.ExoPlayerLibraryInfo"), "VERSION_INT");
            field.setAccessible(true);
            return ((Integer) field.get(null)).intValue();
        } catch (Exception unused) {
            return -1;
        }
    }

    public static String urlStringWithoutQueryParameters(String str) {
        Uri parse = Uri.parse(str);
        return new Uri.Builder().scheme(parse.getScheme()).authority(parse.getAuthority()).path(parse.getPath()).build().toString();
    }

    public static void validateAdSdkKey(AppLovinAd appLovinAd, k kVar) {
        if (!(appLovinAd instanceof AppLovinAdBase)) {
            return;
        }
        String S0 = kVar.S0();
        String S02 = ((AppLovinAdBase) appLovinAd).getSdk().S0();
        if (!S0.equals(S02)) {
            u.p("AppLovinAd", "Ad was loaded from sdk with key: " + S02 + ", but is being rendered from sdk with key: " + S0);
            kVar.r().a(k0.g.f23450o);
        }
    }

    public static List<k0.a> getPostbacks(String str, JSONObject jSONObject, String str2, String str3, Map<String, String> map, k kVar) {
        return getPostbacks(str, jSONObject, str2, Collections.emptyMap(), str3, map, false, kVar);
    }

    public static String replaceCommonMacros(boolean z6, String str) {
        return str.replace(PLACEMENT_MACRO, "").replace(SHOWN_OUT_OF_CONTEXT_MACRO, String.valueOf(z6));
    }

    public static void showToast(String str, MaxAd maxAd, Context context) {
        Toast.makeText(context, maxAd.getFormat().getDisplayName() + ": " + str, 1).show();
    }

    public static List<k0.a> getPostbacks(String str, JSONObject jSONObject, String str2, Map<String, String> map, String str3, k kVar) {
        return getPostbacks(str, jSONObject, str2, map, str3, null, false, kVar);
    }

    public static List<k0.a> getPostbacks(String str, JSONObject jSONObject, String str2, Map<String, String> map, String str3, Map<String, String> map2, boolean z6, k kVar) {
        if (map == null) {
            map = new HashMap<>(1);
        }
        Map<String, String> map3 = map;
        map3.put(MACRO_CLCODE, str2);
        return getPostbacks(str, jSONObject, map3, str3, map2, z6, kVar);
    }

    public static List<k0.a> getPostbacks(String str, JSONObject jSONObject, Map<String, String> map, String str2, k kVar) {
        return getPostbacks(str, jSONObject, map, str2, (Map<String, String>) null, kVar);
    }

    public static List<k0.a> getPostbacks(String str, JSONObject jSONObject, Map<String, String> map, String str2, Map<String, String> map2, k kVar) {
        return getPostbacks(str, jSONObject, map, str2, map2, false, kVar);
    }

    public static List<k0.a> getPostbacks(String str, JSONObject jSONObject, Map<String, String> map, String str2, Map<String, String> map2, boolean z6, k kVar) {
        JSONObject jSONObject2 = JsonUtils.getJSONObject(jSONObject, str, new JSONObject());
        ArrayList arrayList = new ArrayList(jSONObject2.length() + 1);
        if (StringUtils.isValidString(str2)) {
            arrayList.add(new k0.a(str2, null, map2, z6));
        }
        if (jSONObject2.length() > 0) {
            Iterator<String> keys = jSONObject2.keys();
            while (keys.hasNext()) {
                try {
                    String next = keys.next();
                    if (!TextUtils.isEmpty(next)) {
                        String optString = jSONObject2.optString(next);
                        String replace = StringUtils.replace(next, map);
                        if (!TextUtils.isEmpty(optString)) {
                            optString = StringUtils.replace(optString, map);
                        }
                        arrayList.add(new k0.a(replace, optString, map2, z6));
                    }
                } catch (Throwable th) {
                    kVar.U0().h(TAG, "Failed to create and add postback url.", th);
                }
            }
        }
        return arrayList;
    }
}