导航菜单

页面标题

页面副标题

OLX India v19.42.007 - b.java 源代码

正在查看: OLX India v19.42.007 应用的 b.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件,支持语法高亮显示。 仅供安全研究与技术分析使用,严禁用于任何非法用途。请遵守相关法律法规。


package com.payu.custombrowser.util;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.graphics.drawable.Drawable;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkInfo;
import android.net.Uri;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.telephony.CellInfo;
import android.telephony.CellInfoCdma;
import android.telephony.CellInfoGsm;
import android.telephony.CellInfoLte;
import android.telephony.CellInfoWcdma;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.webkit.CookieManager;
import android.webkit.WebView;
import android.widget.ImageView;
import com.google.firebase.perf.network.FirebasePerfUrlConnection;
import com.payu.checkoutpro.utils.PayUCheckoutProConstants;
import com.payu.custombrowser.Bank;
import com.payu.custombrowser.bean.CustomBrowserConfig;
import com.payu.custombrowser.f0;
import com.payu.custombrowser.j0;
import com.payu.otpassist.utils.Constants;
import com.payu.payuanalytics.analytics.model.AnalyticsConfig;
import com.payu.ui.model.utils.GlobalVaultResponseCodes;
import com.payu.ui.model.utils.SdkUiConstants;
import com.payu.upisdk.util.UpiConstant;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.Timer;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import javax.net.ssl.HttpsURLConnection;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class b {
    public static String a;
    public static String b;
    private static List c = new a();

    class a extends ArrayList {
        a() {
            add(CBConstant.ERR_CONNECTION_REFUSED);
            add(CBConstant.ERR_CONNECTION_ABORTED);
            add(CBConstant.ERR_INTERNET_DISCONNECTED);
            add(CBConstant.ERR_ADDRESS_UNREACHABLE);
            add(CBConstant.ERR_CONNECTION_RESET);
            add(CBConstant.ERR_FAILED);
        }
    }

    class C0073b extends androidx.vectordrawable.graphics.drawable.b {
        final androidx.vectordrawable.graphics.drawable.c a;

        C0073b(androidx.vectordrawable.graphics.drawable.c cVar) {
            this.a = cVar;
        }

        public void onAnimationEnd(Drawable drawable) {
            this.a.start();
        }
    }

    public static void A(ImageView imageView, Context context) {
        androidx.vectordrawable.graphics.drawable.c a2 = androidx.vectordrawable.graphics.drawable.c.a(context, f0.payu_loader);
        imageView.setImageDrawable(a2);
        if (a2 != null) {
            a2.c(new C0073b(a2));
            a2.start();
        }
    }

    public static void B(Bank bank, String str, String str2) {
        if (bank != null) {
            bank.addEventAnalytics(str, str2);
        }
    }

    public static void D(InputStream inputStream) {
        try {
            inputStream.close();
        } catch (IOException e) {
            Log.d("PAYU CBUtil", "Exception: " + e.getMessage());
        }
    }

    public static void F(String str) {
        int indexOf;
        CookieManager cookieManager = CookieManager.getInstance();
        String cookie = cookieManager.getCookie(str);
        if (TextUtils.isEmpty(cookie)) {
            com.payu.custombrowser.bean.b.SINGLETON.removeDomain(str);
        } else {
            for (String str2 : cookie.split("; ")) {
                if (!TextUtils.isEmpty(str2) && (indexOf = str2.indexOf(61)) != -1) {
                    cookieManager.setCookie(str, str2.substring(0, indexOf) + "=; ");
                    com.payu.custombrowser.bean.b.SINGLETON.removeDomain(str);
                }
            }
        }
        d.c("List Saved: " + com.payu.custombrowser.bean.b.SINGLETON.getDomainListofSession());
    }

    public static void G(String str, String str2, String str3) {
        if (str2 != null) {
            try {
                if (str2.trim().equals("")) {
                    return;
                }
                Field declaredField = Class.forName(str).getDeclaredField(str3);
                declaredField.setAccessible(true);
                declaredField.set(null, str2);
                declaredField.setAccessible(false);
            } catch (Exception unused) {
            }
        }
    }

    public static boolean J(PaymentOption paymentOption) {
        try {
            b.class.getClassLoader().loadClass(paymentOption.getClassName());
            return true;
        } catch (ClassNotFoundException unused) {
            Log.e("PAYU CBUtil", "Please import " + paymentOption.getPackageName().toLowerCase() + " to make Payment by " + paymentOption.toString());
            return false;
        }
    }

    public static String N(String str, Context context) {
        String str2 = "";
        try {
            String cookie = CookieManager.getInstance().getCookie(CBConstant.PAYU_DOMAIN);
            if (cookie != null) {
                for (String str3 : cookie.split(";")) {
                    if (str3.contains(str)) {
                        str2 = str3.split(Constants.EQUALS)[1];
                    }
                }
            }
        } catch (Exception unused) {
        }
        return str2;
    }

    public static String P(HashMap hashMap) {
        return (String) hashMap.get("bankcode");
    }

    public static ArrayList Q() {
        ArrayList arrayList = new ArrayList();
        arrayList.add("WR7");
        arrayList.add("R6W");
        arrayList.add("646Z");
        return arrayList;
    }

    public static boolean T(String str) {
        return c.contains(str);
    }

    public static String X(HashMap hashMap) {
        String str = (String) hashMap.get("pg");
        return (str == null || !(str.equalsIgnoreCase("cc") || str.equalsIgnoreCase("dc"))) ? (str == null || !str.equalsIgnoreCase("nb")) ? str : CBConstant.NETBANKING : "Cards";
    }

    public static ArrayList Y() {
        ArrayList arrayList = new ArrayList();
        arrayList.add("WR7");
        arrayList.add("R6W");
        arrayList.add("646Z");
        return arrayList;
    }

    private int a(Context context, NetworkInfo networkInfo) {
        try {
            int i = 0;
            for (CellInfo cellInfo : ((TelephonyManager) context.getSystemService("phone")).getAllCellInfo()) {
                if (cellInfo.isRegistered()) {
                    if (cellInfo instanceof CellInfoGsm) {
                        i = ((CellInfoGsm) cellInfo).getCellSignalStrength().getDbm();
                    } else if (cellInfo instanceof CellInfoCdma) {
                        i = ((CellInfoCdma) cellInfo).getCellSignalStrength().getDbm();
                    } else if (cellInfo instanceof CellInfoLte) {
                        i = ((CellInfoLte) cellInfo).getCellSignalStrength().getDbm();
                    } else if (cellInfo instanceof CellInfoWcdma) {
                        i = ((CellInfoWcdma) cellInfo).getCellSignalStrength().getDbm();
                    }
                }
            }
            return i;
        } catch (Exception unused) {
            return 0;
        }
    }

    public static boolean a0(String str, String str2) {
        try {
            JSONObject jSONObject = new JSONObject(str);
            if (jSONObject.has(str2)) {
                if (jSONObject.getBoolean(str2)) {
                    return true;
                }
            }
        } catch (Exception unused) {
        }
        return false;
    }

    private int c(JSONObject jSONObject) {
        if (jSONObject.has(CBConstant.WARN) && jSONObject.getBoolean(CBConstant.WARN) && jSONObject.has(CBConstant.FAIL) && jSONObject.getBoolean(CBConstant.FAIL)) {
            return 3;
        }
        if (jSONObject.has(CBConstant.FAIL) && jSONObject.getBoolean(CBConstant.FAIL)) {
            return 2;
        }
        if (jSONObject.has(CBConstant.WARN)) {
            if (jSONObject.getBoolean(CBConstant.WARN)) {
                return 1;
            }
        }
        return 0;
    }

    public static AnalyticsConfig c0(String str) {
        AnalyticsConfig analyticsConfig = new AnalyticsConfig();
        analyticsConfig.setInitiatorIdentifier("com.payu.custombrowser".concat(str));
        return analyticsConfig;
    }

    public static AlertDialog.Builder d(Activity activity, DialogInterface.OnClickListener onClickListener, String str, String str2, String str3, String str4) {
        AlertDialog.Builder builder = new AlertDialog.Builder(activity, j0.cb_dialog);
        if (onClickListener != null) {
            if (str3 != null) {
                builder.setTitle(str3);
            }
            if (str4 != null) {
                builder.setMessage(str4);
            }
            if (str != null) {
                builder.setPositiveButton(str, onClickListener);
            }
            if (str2 != null) {
                builder.setNegativeButton(str2, onClickListener);
            }
        }
        return builder;
    }

    private boolean e0(Context context, String str) {
        return context.checkCallingOrSelfPermission(str) == 0;
    }

    private SnoozeConfigMap f(Context context, JSONArray jSONArray, SnoozeConfigMap snoozeConfigMap) {
        String str = CBConstant.DISABLE_SP_FOR;
        try {
            int length = jSONArray.length();
            int i = 0;
            for (int i2 = 0; i2 < length; i2++) {
                JSONObject jSONObject = jSONArray.getJSONObject(i2);
                String obj = jSONObject.get("url").toString();
                String obj2 = jSONObject.get(CBConstant.PROGRESS_PERCENT).toString();
                String obj3 = jSONObject.get(CBConstant.TIME_OUT).toString();
                if (jSONObject.has(str)) {
                    try {
                        i = c(jSONObject.getJSONObject(str));
                    } catch (JSONException unused) {
                    }
                }
                StringTokenizer stringTokenizer = new StringTokenizer(obj, CBConstant.CB_DELIMITER);
                while (stringTokenizer.hasMoreTokens()) {
                    String nextToken = stringTokenizer.nextToken();
                    String trim = nextToken.contentEquals(CBConstant.DEFAULT_PAYMENT_URLS) ? CBConstant.DEFAULT_PAYMENT_URLS : nextToken.trim();
                    StringBuilder sb = new StringBuilder();
                    String str2 = str;
                    sb.append(obj2.trim());
                    sb.append(CBConstant.CB_DELIMITER);
                    sb.append(obj3.trim());
                    sb.append(CBConstant.CB_DELIMITER);
                    sb.append(i);
                    h.d(context, CBConstant.SNOOZE_SHARED_PREF, trim, sb.toString());
                    snoozeConfigMap.put(nextToken.contentEquals(CBConstant.DEFAULT_PAYMENT_URLS) ? CBConstant.DEFAULT_PAYMENT_URLS : nextToken.trim(), obj2.trim() + CBConstant.CB_DELIMITER + obj3.trim() + CBConstant.CB_DELIMITER + i);
                    str = str2;
                }
            }
        } catch (JSONException unused2) {
        }
        return snoozeConfigMap;
    }

    private static String f0(Context context) {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
        } catch (PackageManager.NameNotFoundException unused) {
            return "";
        }
    }

    public static String h() {
        try {
            return new SimpleDateFormat(PayUCheckoutProConstants.CP_TIME_FORMAT).format(new Date(System.currentTimeMillis()));
        } catch (Exception unused) {
            return "";
        }
    }

    public static String i(int i) {
        switch (i) {
            case 0:
                return "The certificate is not yet valid.";
            case 1:
                return "The certificate has expired.";
            case 2:
                return "Hostname mismatch.";
            case 3:
                return "The certificate authority is not trusted.";
            case 4:
                return "The date of the certificate is invalid.";
            case 5:
                return "A generic error occurred.";
            case 6:
                return "The number of different SSL errors.";
            default:
                return "Something went wrong.";
        }
    }

    public static String j0(Context context) {
        return h.h(context, "com.payu.custombrowser.payucustombrowser", CBConstant.WEBVIEW_VERSION, "");
    }

    public static String k(Context context, String str, String str2, String str3, String str4, String str5, String str6) {
        try {
            JSONObject jSONObject = new JSONObject();
            jSONObject.put("payu_id", N(CBConstant.PAYUID, context));
            jSONObject.put("txnid", str5);
            jSONObject.put("merchant_key", str4);
            if (str6 == null) {
                str6 = "";
            }
            jSONObject.put("page_type", str6);
            jSONObject.put("event_key", str);
            jSONObject.put("event_value", URLEncoder.encode(str2, "UTF-8"));
            if (str3 == null) {
                str3 = "";
            }
            jSONObject.put("bank", str3);
            jSONObject.put("package_name", context.getPackageName());
            jSONObject.put("ts", h());
            jSONObject.put("application_version", f0(context));
            jSONObject.put(UpiConstant.CB_VERSION_NAME, "7.15.2");
            return jSONObject.toString();
        } catch (Exception unused) {
            return "{}";
        }
    }

    public static String k0(String str) {
        if (str != null) {
            try {
                URL url = new URL(str);
                String protocol = url.getProtocol();
                String host = url.getHost();
                int port = url.getPort();
                return port == -1 ? String.format("%s://%s", protocol, host) : String.format("%s://%s:%d", protocol, host, Integer.valueOf(port));
            } catch (MalformedURLException unused) {
            }
        }
        return null;
    }

    public static String m(WebView webView) {
        Matcher matcher = Pattern.compile("(Chrome\\/(.*?)\\s)").matcher(webView.getSettings().getUserAgentString());
        if (matcher.find()) {
            return matcher.group(2);
        }
        return null;
    }

    public static HttpsURLConnection m0(String str) {
        try {
            HttpsURLConnection httpsURLConnection = (HttpsURLConnection) ((URLConnection) FirebasePerfUrlConnection.instrument(new URL(str).openConnection()));
            httpsURLConnection.setRequestMethod(PayUCheckoutProConstants.CP_GET);
            httpsURLConnection.setSSLSocketFactory(new i());
            httpsURLConnection.setRequestProperty("Accept-Charset", "UTF-8");
            return httpsURLConnection;
        } catch (Exception unused) {
            return null;
        }
    }

    public static String n(FileInputStream fileInputStream) {
        StringBuilder sb = new StringBuilder();
        int i = 0;
        while (true) {
            try {
                int read = fileInputStream.read();
                if (read == -1) {
                    break;
                }
                if (i % 2 == 0) {
                    sb.append((char) (read - ((i % 5) + 1)));
                } else {
                    sb.append((char) (read + (i % 5) + 1));
                }
                i++;
            } catch (IOException unused) {
            }
        }
        fileInputStream.close();
        return sb.toString();
    }

    public static void n0(Context context, String str) {
        if (str != null) {
            h.d(context, "com.payu.custombrowser.payucustombrowser", CBConstant.WEBVIEW_VERSION, str);
        }
    }

    public static String o(Object obj) {
        String valueOf = String.valueOf(obj);
        if (valueOf.equals("null")) {
            return null;
        }
        return valueOf;
    }

    public static boolean o0(Context context) {
        NetworkInfo activeNetworkInfo = ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo();
        return activeNetworkInfo != null && activeNetworkInfo.isAvailable() && activeNetworkInfo.isConnected();
    }

    public static String p(String str, Double d) {
        String hexString = Long.toHexString(Math.round(d.doubleValue() * 255.0d));
        if (hexString.length() == 1) {
            hexString = "0" + hexString;
        }
        return str.replace(SdkUiConstants.HASH, SdkUiConstants.HASH + hexString);
    }

    public static String q0(String str) {
        Matcher matcher = Pattern.compile("((?<=[?&]id=)[^&]+)").matcher(str);
        if (matcher.find()) {
            return matcher.group(1);
        }
        return null;
    }

    private String r(HashMap hashMap) {
        StringBuilder sb = new StringBuilder();
        for (String str : hashMap.keySet()) {
            sb.append(str);
            sb.append(Constants.EQUALS);
            sb.append((String) hashMap.get(str));
            sb.append(Constants.AMPERSAND);
        }
        return sb.toString().substring(0, sb.lastIndexOf(Constants.AMPERSAND));
    }

    public static boolean s0(String str) {
        return str.startsWith(CBConstant.PLAY_STORE_URL) || str.startsWith(CBConstant.PLAY_STORE_MARKET_URI);
    }

    public static int t0(String str) {
        if (str == null) {
            return 0;
        }
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException unused) {
            return 0;
        }
    }

    public static void u(Context context, View view) {
        ((InputMethodManager) context.getSystemService("input_method")).hideSoftInputFromWindow(view.getWindowToken(), 0);
    }

    public static String u0(String str) {
        try {
            if (!str.contains(CBConstant.CB_DELIMITER)) {
                return str.length() > 128 ? str.substring(0, 127) : str;
            }
            StringTokenizer stringTokenizer = new StringTokenizer(str, CBConstant.CB_DELIMITER);
            String nextToken = stringTokenizer.nextToken();
            String nextToken2 = stringTokenizer.nextToken();
            if (nextToken.length() > 128) {
                nextToken = nextToken.substring(0, 125);
            }
            if (nextToken2.length() > 128) {
                nextToken2 = nextToken2.substring(0, 125);
            }
            return nextToken + CBConstant.CB_DELIMITER + nextToken2;
        } catch (Exception unused) {
            return "";
        }
    }

    public static void w(Context context, String str, String str2) {
        String str3;
        String q0 = q0(str);
        if (q0 == null) {
            str3 = "";
        } else {
            str3 = "details?id=" + q0;
        }
        n0(context, str2);
        try {
            context.startActivity(new Intent("android.intent.action.VIEW", Uri.parse(CBConstant.PLAY_STORE_MARKET_URI + str3)));
        } catch (ActivityNotFoundException unused) {
            context.startActivity(new Intent("android.intent.action.VIEW", Uri.parse("https://play.google.com/store/apps/" + str3)));
        }
    }

    public static void x(Context context, String str, String str2, String str3, String str4, String str5, String str6, String str7, String str8) {
        HashMap hashMap = new HashMap();
        hashMap.put("cta_name", str);
        hashMap.put(SdkUiConstants.CP_CTA_PAGE, str2);
        hashMap.put(SdkUiConstants.CP_TIME, str8);
        hashMap.put(SdkUiConstants.CP_TIMEIN_MILISECONDS, Double.valueOf(Double.parseDouble(str8) / 1000.0d));
        hashMap.put("Flow Type", str6);
        hashMap.put("Bank Code", str5);
        hashMap.put("Screen Type", str7);
        new com.payu.custombrowser.analytics.a().b(context, str3, hashMap, str4);
    }

    public static void y(Context context, String str, String str2, String str3, String str4, String str5, String str6, String str7, String str8, String str9) {
        HashMap hashMap = new HashMap();
        hashMap.put("cta_name", str);
        hashMap.put(SdkUiConstants.CP_CTA_PAGE, str2);
        hashMap.put(SdkUiConstants.CP_TIME, str8);
        hashMap.put(SdkUiConstants.CP_TIMEIN_MILISECONDS, Double.valueOf(Double.parseDouble(str8) / 1000.0d));
        hashMap.put("Flow Type", str6);
        hashMap.put("Bank Code", str5);
        hashMap.put("Screen Type", str7);
        String str10 = a;
        if (str10 == null) {
            str10 = "";
        }
        hashMap.put("URL", str10);
        String str11 = b;
        if (str11 == null) {
            str11 = "";
        }
        hashMap.put("URLState", str11);
        if (str9 == null) {
            str9 = "";
        }
        hashMap.put("msg", str9);
        new com.payu.custombrowser.analytics.a().b(context, str3, hashMap, str4);
    }

    public static void z(Context context, String str, String str2, boolean z, String str3) {
        HashMap hashMap = new HashMap();
        long seconds = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis());
        hashMap.put(SdkUiConstants.CP_TIME, Long.valueOf(seconds));
        hashMap.put(SdkUiConstants.CP_TIMEIN_MILISECONDS, Long.valueOf(seconds / 1000));
        hashMap.put("cta_name", str);
        hashMap.put(SdkUiConstants.CP_CTA_PAGE, str2);
        hashMap.put(SdkUiConstants.CP_CTA_TYPE, SdkUiConstants.CP_TYPE_ACTION);
        hashMap.put(SdkUiConstants.CP_SECTION_NAME, SdkUiConstants.CP_LEFT_SIDEBAR);
        if (z) {
            hashMap.put(SdkUiConstants.SDK_CLOSED, "Yes");
        } else {
            hashMap.put(SdkUiConstants.SDK_CLOSED, "No");
        }
        new com.payu.custombrowser.analytics.a().b(context, SdkUiConstants.CP_BACK_BUTTON, hashMap, str3);
    }

    public void C(CustomBrowserConfig customBrowserConfig) {
        CookieManager cookieManager = CookieManager.getInstance();
        com.payu.custombrowser.bean.b bVar = com.payu.custombrowser.bean.b.SINGLETON;
        if (bVar.getDomainListofSession() == null || bVar.getDomainListofSession().size() <= 0 || customBrowserConfig.getDomainUrlListToUnclear() == null || customBrowserConfig.getDomainUrlListToUnclear().size() <= 0) {
            if (customBrowserConfig == null || customBrowserConfig.getDomainUrlListToUnclear() == null || !customBrowserConfig.getDomainUrlListToUnclear().isEmpty()) {
                return;
            }
            cookieManager.removeSessionCookies(null);
            return;
        }
        for (String str : bVar.getDomainListofSession()) {
            if (customBrowserConfig.getDomainUrlListToUnclear().isEmpty() || !customBrowserConfig.getDomainUrlListToUnclear().contains(str)) {
                if (str != null) {
                    F(str);
                }
            }
        }
    }

    public void E(InputStream inputStream, Context context, String str, int i) {
        try {
            GZIPInputStream gZIPInputStream = new GZIPInputStream(inputStream);
            byte[] bArr = new byte[1024];
            FileOutputStream openFileOutput = context.openFileOutput(str, i);
            while (true) {
                int read = gZIPInputStream.read(bArr);
                if (read <= 0) {
                    gZIPInputStream.close();
                    openFileOutput.close();
                    return;
                }
                openFileOutput.write(bArr, 0, read);
            }
        } catch (IOException | Exception unused) {
        }
    }

    public void H(String str, boolean z, Context context) {
        h.e(context, "com.payu.custombrowser.payucustombrowser", str, z);
    }

    public void I(Timer timer) {
        if (timer != null) {
            timer.cancel();
            timer.purge();
        }
    }

    public boolean K(String str, Context context) {
        try {
            return h.j(context, "com.payu.custombrowser.payucustombrowser", str, true);
        } catch (Exception unused) {
            h.m(context, "com.payu.custombrowser.payucustombrowser");
            return true;
        }
    }

    public NetworkInfo L(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
        NetworkInfo networkInfo = null;
        for (Network network : connectivityManager.getAllNetworks()) {
            NetworkInfo networkInfo2 = connectivityManager.getNetworkInfo(network);
            if (networkInfo2.getState().equals(NetworkInfo.State.CONNECTED)) {
                networkInfo = networkInfo2;
            }
        }
        return networkInfo;
    }

    public String M(Context context, String str) {
        String str2 = "";
        try {
            String cookie = CookieManager.getInstance().getCookie(str);
            if (cookie != null) {
                for (String str3 : cookie.split(";")) {
                    String[] split = str3.split(Constants.EQUALS);
                    str2 = str2 + split[0] + Constants.EQUALS + split[1] + ";";
                }
            }
            return str2.length() > 0 ? str2.substring(0, str2.length() - 1) : str2;
        } catch (Exception unused) {
            return "";
        }
    }

    public String O(String str, String str2) {
        JSONObject jSONObject = new JSONObject(str);
        if (jSONObject.has(str2)) {
            return jSONObject.get(str2).toString();
        }
        throw new JSONException("Key not found");
    }

    public void R(Context context, String str, String str2) {
        h.d(context, "com.payu.custombrowser.payucustombrowser.js", str, str2);
    }

    public void S(CustomBrowserConfig customBrowserConfig) {
        C(customBrowserConfig);
    }

    public String U(Context context) {
        if (context != null) {
            try {
                NetworkInfo activeNetworkInfo = ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo();
                if (activeNetworkInfo != null && activeNetworkInfo.isConnected()) {
                    if (activeNetworkInfo.getType() == 1) {
                        return "WIFI";
                    }
                    if (activeNetworkInfo.getType() == 0) {
                        switch (activeNetworkInfo.getSubtype()) {
                            case 1:
                                return "GPRS";
                            case 2:
                                return "EDGE";
                            case 3:
                            case 5:
                            case 6:
                            case CBConstant.SUBMIT_OTP_COLLAPSED:
                            case 9:
                            case 10:
                                return "HSPA";
                            case 4:
                                return "CDMA";
                            case 7:
                            case GlobalVaultResponseCodes.GV_VERIFY_OTP_SUCCESS:
                                return "2G";
                            case 12:
                            case 14:
                            case 15:
                                return "3G";
                            case 13:
                                return "4G";
                            default:
                                return "?";
                        }
                    }
                }
                return "Not connected";
            } catch (Exception unused) {
            }
        }
        return "?";
    }

    public String V(Context context, String str) {
        try {
            return h.h(context, "com.payu.custombrowser.payucustombrowser", str, "");
        } catch (Exception unused) {
            h.m(context, "com.payu.custombrowser.payucustombrowser");
            return "";
        }
    }

    public String W(String str) {
        HashMap g0 = g0(str);
        String str2 = g0.containsKey("sdk_platform") ? (String) g0.get("sdk_platform") : "";
        try {
            JSONArray jSONArray = !TextUtils.isEmpty(str2) ? new JSONArray(str2) : new JSONArray();
            JSONObject jSONObject = new JSONObject();
            jSONObject.put("platform", "android");
            jSONObject.put("name", CBConstant.NAME_VALUE);
            jSONObject.put("version", "7.15.2");
            jSONArray.put(jSONObject);
            g0.put("sdk_platform", jSONArray.toString());
            return r(g0);
        } catch (JSONException unused) {
            return r(g0);
        }
    }

    public void Z(Context context, String str, String str2) {
        h.d(context, "com.payu.custombrowser.payucustombrowser", str, str2);
    }

    public int b(SnoozeConfigMap snoozeConfigMap, String str) {
        if (snoozeConfigMap == null || str == null) {
            return 0;
        }
        for (Object obj : snoozeConfigMap.keySet()) {
            if (str.startsWith(obj.toString())) {
                return snoozeConfigMap.getPercentageAndTimeout(obj.toString())[2];
            }
        }
        return snoozeConfigMap.getPercentageAndTimeout(CBConstant.DEFAULT_PAYMENT_URLS)[2];
    }

    public int b0(Context context) {
        NetworkInfo L = L(context);
        if (L != null) {
            if (L.getTypeName().equalsIgnoreCase("MOBILE")) {
                return a(context, L);
            }
            if (L.getTypeName().equalsIgnoreCase("wifi") && e0(context, "android.permission.ACCESS_WIFI_STATE")) {
                try {
                    WifiInfo connectionInfo = ((WifiManager) context.getSystemService("wifi")).getConnectionInfo();
                    if (connectionInfo != null) {
                        return WifiManager.calculateSignalLevel(connectionInfo.getRssi(), 5);
                    }
                } catch (Exception unused) {
                }
            }
        }
        return 0;
    }

    public void d0(Context context, String str, String str2) {
        String V = V(context, str);
        if (!V.equalsIgnoreCase("")) {
            if (V.contains(CBConstant.CB_DELIMITER)) {
                StringTokenizer stringTokenizer = new StringTokenizer(V, CBConstant.CB_DELIMITER);
                stringTokenizer.nextToken();
                str2 = stringTokenizer.nextToken() + CBConstant.CB_DELIMITER + str2;
            } else {
                str2 = V + CBConstant.CB_DELIMITER + str2;
            }
        }
        i0(context, str, str2);
    }

    public Drawable e(Context context, int i) {
        return context.getResources().getDrawable(i, context.getTheme());
    }

    public SnoozeConfigMap g(Map map) {
        SnoozeConfigMap snoozeConfigMap = new SnoozeConfigMap();
        for (Map.Entry entry : map.entrySet()) {
            snoozeConfigMap.put(entry.getKey(), entry.getValue());
        }
        return snoozeConfigMap;
    }

    public HashMap g0(String str) {
        String str2;
        HashMap hashMap = new HashMap();
        if (str != null) {
            StringTokenizer stringTokenizer = new StringTokenizer(str, Constants.AMPERSAND);
            while (stringTokenizer.hasMoreTokens()) {
                String[] split = stringTokenizer.nextToken().split(Constants.EQUALS);
                if (split != null && split.length > 0 && (str2 = split[0]) != null) {
                    hashMap.put(str2, split.length > 1 ? split[1] : "");
                }
            }
        }
        return hashMap;
    }

    public void h0(Context context, String str) {
        try {
            SharedPreferences.Editor edit = h.k(context, "com.payu.custombrowser.payucustombrowser").edit();
            edit.remove(str);
            edit.apply();
        } catch (Exception unused) {
        }
    }

    public void i0(Context context, String str, String str2) {
        h.d(context, "com.payu.custombrowser.payucustombrowser", str, str2);
    }

    public String j(Activity activity) {
        DisplayMetrics displayMetrics = new DisplayMetrics();
        activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
        return displayMetrics.densityDpi + "";
    }

    public String l(Context context, String str, boolean z) {
        try {
            return z ? h.h(context, "com.payu.custombrowser.payucustombrowser", str, CBConstant.UNDEFINED) : h.h(context, "com.payu.custombrowser.payucustombrowser.js", str, CBConstant.UNDEFINED);
        } catch (Exception unused) {
            return CBConstant.UNDEFINED;
        }
    }

    public void l0(Context context, String str) {
        SharedPreferences k = h.k(context, "com.payu.custombrowser.payucustombrowser.js");
        if (k != null) {
            SharedPreferences.Editor edit = k.edit();
            edit.remove(str);
            edit.apply();
        }
    }

    public SnoozeConfigMap p0(Context context, String str) {
        SnoozeConfigMap snoozeConfigMap = new SnoozeConfigMap();
        try {
            JSONObject jSONObject = new JSONObject(str);
            h.m(context, CBConstant.SNOOZE_SHARED_PREF);
            SnoozeConfigMap f = f(context, jSONObject.getJSONArray("default"), snoozeConfigMap);
            jSONObject.remove("default");
            Iterator<String> keys = jSONObject.keys();
            return keys.hasNext() ? f(context, jSONObject.getJSONArray(keys.next()), f) : f;
        } catch (JSONException unused) {
            return snoozeConfigMap;
        }
    }

    public String q(String str, String str2) {
        for (String str3 : str.split(Constants.AMPERSAND)) {
            String[] split = str3.split(Constants.EQUALS);
            if (split.length >= 2 && split[0].equalsIgnoreCase(str2)) {
                return split[1];
            }
        }
        return "";
    }

    public PaymentOption r0(String str) {
        if (TextUtils.isEmpty(str)) {
            return null;
        }
        String q = q(str, "bankcode");
        if (TextUtils.isEmpty(q)) {
            return null;
        }
        for (PaymentOption paymentOption : PaymentOption.values()) {
            if (paymentOption.getPaymentName().equalsIgnoreCase(q)) {
                return paymentOption;
            }
        }
        return null;
    }

    public HttpsURLConnection s(String str, String str2, int i, String str3) {
        try {
            HttpsURLConnection httpsURLConnection = (HttpsURLConnection) ((URLConnection) FirebasePerfUrlConnection.instrument(new URL(str).openConnection()));
            httpsURLConnection.setRequestMethod("POST");
            if (i != -1) {
                httpsURLConnection.setConnectTimeout(i);
            }
            httpsURLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            if (str2 != null) {
                httpsURLConnection.setRequestProperty("Content-Length", String.valueOf(str2.length()));
            }
            if (str3 != null) {
                httpsURLConnection.setRequestProperty("Cookie", str3);
            }
            httpsURLConnection.setSSLSocketFactory(new i());
            httpsURLConnection.setDoOutput(true);
            if (str2 != null) {
                httpsURLConnection.getOutputStream().write(str2.getBytes());
            }
            return httpsURLConnection;
        } catch (Exception unused) {
            return null;
        }
    }

    public void t(Context context) {
        SharedPreferences k = h.k(context, "com.payu.custombrowser.payucustombrowser.js");
        if (k != null) {
            SharedPreferences.Editor edit = k.edit();
            edit.clear();
            edit.apply();
        }
    }

    public void v(Context context, String str) {
        try {
            SharedPreferences.Editor edit = h.k(context, "com.payu.custombrowser.payucustombrowser").edit();
            edit.remove(str);
            edit.apply();
        } catch (Exception unused) {
        }
    }
}