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/helpshift/util/ActivityUtil.java

@@ -0,0 +1,17 @@
+package com.helpshift.util;
+
+import android.app.Activity;
+import android.content.Intent;
+
+/* loaded from: classes3.dex */
+public abstract class ActivityUtil {
+    public static void startLauncherActivityAndFinish(Activity activity) {
+        if (activity != null) {
+            Intent launchIntent = ApplicationUtil.getLaunchIntent(activity, activity.getPackageName());
+            if (launchIntent != null) {
+                activity.startActivity(launchIntent);
+            }
+            activity.finish();
+        }
+    }
+}

decompiled/sources/com/helpshift/util/ApplicationUtil.java

@@ -0,0 +1,97 @@
+package com.helpshift.util;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.Intent;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.content.ContextCompat;
+import com.helpshift.activities.HSMainActivity;
+import com.helpshift.log.HSLogger;
+
+/* loaded from: classes3.dex */
+public abstract class ApplicationUtil {
+    public static boolean isApplicationInDebugMode(Context context) {
+        return (context.getApplicationInfo().flags & 2) != 0;
+    }
+
+    public static boolean isPermissionGranted(Context context, String str) {
+        try {
+            return ContextCompat.checkSelfPermission(context, str) == 0;
+        } catch (Exception e) {
+            HSLogger.d("AppUtil", "Error checking for permission : " + str, e);
+            return false;
+        }
+    }
+
+    public static void showNotification(Context context, Notification notification, Class cls) {
+        if (notification == null) {
+            HSLogger.d("AppUtil", "notification is null, not showing.");
+            return;
+        }
+        NotificationManager notificationManager = getNotificationManager(context);
+        if (notificationManager == null) {
+            HSLogger.d("AppUtil", "NotificationManager is null, not showing.");
+            return;
+        }
+        try {
+            boolean areNotificationsEnabled = NotificationManagerCompat.from(context).areNotificationsEnabled();
+            HSLogger.d("AppUtil", "areNotificationAllowed : " + areNotificationsEnabled);
+            if (areNotificationsEnabled) {
+                String generateNotificationTag = generateNotificationTag(cls);
+                HSLogger.d("AppUtil", "Showing notification : Tag : " + generateNotificationTag);
+                notificationManager.notify(generateNotificationTag, 121, notification);
+            }
+        } catch (Exception e) {
+            HSLogger.e("AppUtil", "Error showing notification", e);
+        }
+    }
+
+    public static NotificationManager getNotificationManager(Context context) {
+        try {
+            return (NotificationManager) context.getSystemService("notification");
+        } catch (Exception e) {
+            HSLogger.e("AppUtil", "Unable to get notification manager from System service", e);
+            return null;
+        }
+    }
+
+    public static int getLogoResourceValue(Context context) {
+        int i = context.getApplicationInfo().logo;
+        return i == 0 ? context.getApplicationInfo().icon : i;
+    }
+
+    public static int getTargetSDKVersion(Context context) {
+        try {
+            return context.getApplicationInfo().targetSdkVersion;
+        } catch (Exception e) {
+            HSLogger.d("AppUtil", "Target SDK version not found", e);
+            return 0;
+        }
+    }
+
+    public static void cancelNotification(Context context) {
+        HSLogger.d("AppUtil", "Cancelling notification");
+        NotificationManager notificationManager = getNotificationManager(context);
+        if (notificationManager != null) {
+            notificationManager.cancel(generateNotificationTag(HSMainActivity.class), 121);
+        }
+    }
+
+    public static int getResourceIdFromName(Context context, String str, String str2, String str3) {
+        return context.getResources().getIdentifier(str, str2, str3);
+    }
+
+    public static Intent getLaunchIntent(Context context, String str) {
+        try {
+            return context.getPackageManager().getLaunchIntentForPackage(str);
+        } catch (Exception e) {
+            HSLogger.e("AppUtil", "Error getting launch activity for package : " + str, e);
+            return null;
+        }
+    }
+
+    public static String generateNotificationTag(Class cls) {
+        return "hsft_notification_tag_" + cls.getName();
+    }
+}

decompiled/sources/com/helpshift/util/AssetsUtil.java

@@ -0,0 +1,87 @@
+package com.helpshift.util;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.util.Log;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+/* loaded from: classes3.dex */
+public abstract class AssetsUtil {
+    public static boolean resourceExists(Context context, int i) {
+        if (context == null || i == 0) {
+            return false;
+        }
+        try {
+            return context.getResources().getResourceName(i) != null;
+        } catch (Resources.NotFoundException unused) {
+            return false;
+        }
+    }
+
+    public static String readAssetFileContents(Context context, String str) {
+        BufferedReader bufferedReader;
+        IOException e;
+        InputStream inputStream;
+        if (context == null) {
+            return "";
+        }
+        InputStream inputStream2 = null;
+        try {
+            StringBuilder sb = new StringBuilder();
+            inputStream = context.getAssets().open(str);
+            try {
+                bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+                while (true) {
+                    try {
+                        try {
+                            String readLine = bufferedReader.readLine();
+                            if (readLine != null) {
+                                sb.append(readLine);
+                            } else {
+                                String sb2 = sb.toString();
+                                Utils.closeQuietly(inputStream);
+                                Utils.closeQuietly(bufferedReader);
+                                return sb2;
+                            }
+                        } catch (IOException e2) {
+                            e = e2;
+                            Log.e("astsUtl", "Error in reading the file contents", e);
+                            Utils.closeQuietly(inputStream);
+                            Utils.closeQuietly(bufferedReader);
+                            return "";
+                        }
+                    } catch (Throwable th) {
+                        th = th;
+                        inputStream2 = inputStream;
+                        Utils.closeQuietly(inputStream2);
+                        Utils.closeQuietly(bufferedReader);
+                        throw th;
+                    }
+                }
+            } catch (IOException e3) {
+                e = e3;
+                bufferedReader = null;
+            } catch (Throwable th2) {
+                th = th2;
+                bufferedReader = null;
+                inputStream2 = inputStream;
+                Utils.closeQuietly(inputStream2);
+                Utils.closeQuietly(bufferedReader);
+                throw th;
+            }
+        } catch (IOException e4) {
+            bufferedReader = null;
+            e = e4;
+            inputStream = null;
+        } catch (Throwable th3) {
+            th = th3;
+            bufferedReader = null;
+            Utils.closeQuietly(inputStream2);
+            Utils.closeQuietly(bufferedReader);
+            throw th;
+        }
+    }
+}

decompiled/sources/com/helpshift/util/ConfigValues.java

@@ -0,0 +1,20 @@
+package com.helpshift.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public abstract class ConfigValues {
+    public static Map getDefaultConfigMap() {
+        HashMap hashMap = new HashMap();
+        Boolean bool = Boolean.FALSE;
+        hashMap.put("enableLogging", bool);
+        hashMap.put("notificationChannelId", "");
+        hashMap.put("notificationSoundId", 0);
+        hashMap.put("notificationIcon", 0);
+        hashMap.put("notificationLargeIcon", 0);
+        hashMap.put("manualLifecycleTracking", bool);
+        hashMap.put("enableInAppNotification", Boolean.TRUE);
+        return hashMap;
+    }
+}

decompiled/sources/com/helpshift/util/FileUtil.java

@@ -0,0 +1,63 @@
+package com.helpshift.util;
+
+import com.helpshift.log.HSLogger;
+import java.io.File;
+import java.io.FileInputStream;
+
+/* loaded from: classes3.dex */
+public abstract class FileUtil {
+    public static String readFileToString(String str) {
+        FileInputStream fileInputStream;
+        Exception e;
+        FileInputStream fileInputStream2 = null;
+        try {
+            File file = new File(str);
+            fileInputStream = new FileInputStream(file);
+            try {
+                try {
+                    int length = (int) file.length();
+                    byte[] bArr = new byte[length];
+                    fileInputStream.read(bArr, 0, length);
+                    String str2 = new String(bArr);
+                    Utils.closeQuietly(fileInputStream);
+                    return str2;
+                } catch (Exception e2) {
+                    e = e2;
+                    HSLogger.e("fileutil", "Error reading file: " + str, e);
+                    Utils.closeQuietly(fileInputStream);
+                    return "";
+                }
+            } catch (Throwable th) {
+                th = th;
+                fileInputStream2 = fileInputStream;
+                Utils.closeQuietly(fileInputStream2);
+                throw th;
+            }
+        } catch (Exception e3) {
+            fileInputStream = null;
+            e = e3;
+        } catch (Throwable th2) {
+            th = th2;
+            Utils.closeQuietly(fileInputStream2);
+            throw th;
+        }
+    }
+
+    public static void deleteDir(String str) {
+        File file = new File(str);
+        if (file.exists()) {
+            File[] listFiles = file.listFiles();
+            if (listFiles == null || listFiles.length == 0) {
+                file.delete();
+                return;
+            }
+            for (File file2 : listFiles) {
+                if (file2.isDirectory()) {
+                    deleteDir(file2.getAbsolutePath());
+                }
+                file2.delete();
+            }
+            file.delete();
+        }
+    }
+}

decompiled/sources/com/helpshift/util/HSTimer.java

@@ -0,0 +1,25 @@
+package com.helpshift.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public abstract class HSTimer {
+    public static final Map sourceTimer = new HashMap();
+
+    public static void setStartTime(String str) {
+        sourceTimer.put(str, Long.valueOf(System.currentTimeMillis()));
+    }
+
+    public static long endTimer(String str) {
+        long currentTimeMillis = System.currentTimeMillis();
+        if (Utils.isEmpty(str)) {
+            return -1L;
+        }
+        Map map = sourceTimer;
+        if (map.containsKey(str)) {
+            return currentTimeMillis - ((Long) map.remove(str)).longValue();
+        }
+        return -1L;
+    }
+}

decompiled/sources/com/helpshift/util/ListUtil.java

@@ -0,0 +1,14 @@
+package com.helpshift.util;
+
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public abstract class ListUtil {
+    public static boolean isEmpty(List list) {
+        return list == null || list.isEmpty();
+    }
+
+    public static boolean isNotEmpty(List list) {
+        return (list == null || list.isEmpty()) ? false : true;
+    }
+}

decompiled/sources/com/helpshift/util/ResourceCacheUtil.java

@@ -0,0 +1,28 @@
+package com.helpshift.util;
+
+import android.net.Uri;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebResourceResponse;
+import com.helpshift.cache.HelpshiftResourceCacheManager;
+import com.helpshift.log.HSLogger;
+import com.ironsource.nb;
+import java.io.InputStream;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public abstract class ResourceCacheUtil {
+    public static WebResourceResponse getWebResourceResponse(HelpshiftResourceCacheManager helpshiftResourceCacheManager, WebResourceRequest webResourceRequest) {
+        Uri url = webResourceRequest.getUrl();
+        String path = url.getPath();
+        String query = url.getQuery();
+        InputStream fetchCachedResource = helpshiftResourceCacheManager.fetchCachedResource(webResourceRequest.getUrl().toString(), path, query, webResourceRequest.getRequestHeaders());
+        if (fetchCachedResource == null) {
+            HSLogger.e("ResCacheUtil", "Error in receiving response for intercepted request to be cached- " + url + " \n Path: " + path + "\n Query: " + query);
+            return null;
+        }
+        String resourceMimeType = helpshiftResourceCacheManager.getResourceMimeType(path, query);
+        Map cachedResponseHeadersForResource = helpshiftResourceCacheManager.getCachedResponseHeadersForResource(path, query);
+        HSLogger.d("ResCacheUtil", "Response received for intercepted request to be cached- " + url.toString() + " MimeType:" + resourceMimeType);
+        return new WebResourceResponse(resourceMimeType, nb.N, 200, "OK", cachedResponseHeadersForResource, fetchCachedResource);
+    }
+}

decompiled/sources/com/helpshift/util/SafeWrappedRunnable.java

@@ -0,0 +1,21 @@
+package com.helpshift.util;
+
+import com.helpshift.log.HSLogger;
+
+/* loaded from: classes3.dex */
+public class SafeWrappedRunnable implements Runnable {
+    public final Runnable runnable;
+
+    public SafeWrappedRunnable(Runnable runnable) {
+        this.runnable = runnable;
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        try {
+            this.runnable.run();
+        } catch (Exception e) {
+            HSLogger.e("SfeWrpRnnble", "Error running operation", e);
+        }
+    }
+}

decompiled/sources/com/helpshift/util/SchemaUtil.java

@@ -0,0 +1,33 @@
+package com.helpshift.util;
+
+import com.helpshift.HelpshiftInstallException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/* loaded from: classes3.dex */
+public abstract class SchemaUtil {
+    public static final Pattern platformPattern = Pattern.compile("^[\\p{L}\\p{N}-]+_platform_\\d{17}-[0-9a-z]{15}$");
+
+    public static boolean validatePlatformId(String str) {
+        return Utils.isNotEmpty(str) && platformPattern.matcher(str).matches();
+    }
+
+    public static boolean validateDomainName(String str) {
+        if (Utils.isEmpty(str)) {
+            return false;
+        }
+        List asList = Arrays.asList(str.trim().split("\\."));
+        return asList.size() >= 3 && !asList.contains("");
+    }
+
+    public static boolean validateInstallCredentials(String str, String str2) {
+        if (!validateDomainName(str)) {
+            throw new HelpshiftInstallException("The domain name used in the Helpshift.install() is not valid!");
+        }
+        if (validatePlatformId(str2)) {
+            return true;
+        }
+        throw new HelpshiftInstallException("The platform id used in the Helpshift.install() is not valid!");
+    }
+}

decompiled/sources/com/helpshift/util/SdkURLs.java

@@ -0,0 +1,21 @@
+package com.helpshift.util;
+
+/* loaded from: classes3.dex */
+public abstract class SdkURLs {
+    public static String AWS_CACHE_URLS_CONFIG = "https://webchat.helpshift.com/latest/android/android-mapping.json";
+    public static String AWS_WEBCHAT_JS = "https://webchat.helpshift.com/latest/android/webChat.js";
+    public static String HC_CACHE_URLS_CONFIG = "https://d2duuy9yo5pldo.cloudfront.net/hc-android-mapping.json";
+    public static String HELPCENTER_MIDDLEWARE_JS = "https://d2duuy9yo5pldo.cloudfront.net/android/helpcenter.js";
+
+    public static void updateHosts(String str, String str2) {
+        if (!Utils.isEmpty(str)) {
+            AWS_WEBCHAT_JS = "https://" + str + "/latest/android/webChat.js";
+            AWS_CACHE_URLS_CONFIG = "https://" + str + "/latest/android/android-mapping.json";
+        }
+        if (Utils.isEmpty(str2)) {
+            return;
+        }
+        HELPCENTER_MIDDLEWARE_JS = "https://" + str2 + "/android/helpcenter.js";
+        HC_CACHE_URLS_CONFIG = "https://" + str2 + "/hc-android-mapping.json";
+    }
+}

decompiled/sources/com/helpshift/util/Utils.java

@@ -0,0 +1,129 @@
+package com.helpshift.util;
+
+import com.helpshift.log.HSLogger;
+import com.vungle.ads.internal.signals.SignalManager;
+import java.io.Closeable;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes3.dex */
+public abstract class Utils {
+    public static String mapToJsonString(Map map) {
+        return map != null ? new JSONObject(map).toString() : "";
+    }
+
+    public static Map jsonStringToMap(String str) {
+        if (isEmpty(str) || !isValidJsonString(str)) {
+            return new HashMap();
+        }
+        try {
+            HashMap hashMap = new HashMap();
+            JSONObject jSONObject = new JSONObject(str);
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                hashMap.put(next, jSONObject.get(next));
+            }
+            return hashMap;
+        } catch (JSONException e) {
+            HSLogger.e("Utils", "Error in creating map from string json", e);
+            return new HashMap();
+        }
+    }
+
+    public static Map jsonStringToStringMap(String str) {
+        if (isEmpty(str) || !isValidJsonString(str)) {
+            return new HashMap();
+        }
+        try {
+            HashMap hashMap = new HashMap();
+            JSONObject jSONObject = new JSONObject(str);
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                hashMap.put(next, jSONObject.getString(next));
+            }
+            return hashMap;
+        } catch (Exception e) {
+            HSLogger.e("Utils", "Error in creating map from string json", e);
+            return new HashMap();
+        }
+    }
+
+    public static JSONArray listToJSONArray(List list) {
+        if (list == null || list.size() == 0) {
+            return new JSONArray();
+        }
+        return new JSONArray((Collection) list);
+    }
+
+    public static boolean isNotEmpty(String str) {
+        return !isEmpty(str);
+    }
+
+    public static boolean isEmpty(String str) {
+        return str == null || str.trim().length() == 0;
+    }
+
+    public static boolean isNotEmpty(Map map) {
+        return !isEmpty(map);
+    }
+
+    public static boolean isEmpty(Map map) {
+        return map == null || map.isEmpty();
+    }
+
+    public static boolean isEmpty(JSONArray jSONArray) {
+        return jSONArray == null || jSONArray.length() == 0;
+    }
+
+    public static boolean isValidJsonString(String str) {
+        try {
+            try {
+                new JSONObject(str);
+                return true;
+            } catch (Exception unused) {
+                return false;
+            }
+        } catch (Exception unused2) {
+            new JSONArray(str);
+            return true;
+        }
+    }
+
+    public static void closeQuietly(Closeable closeable) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (Exception unused) {
+            }
+        }
+    }
+
+    public static String join(CharSequence charSequence, Iterable iterable) {
+        if (iterable == null) {
+            return null;
+        }
+        StringBuilder sb = new StringBuilder();
+        boolean z = true;
+        for (Object obj : iterable) {
+            if (z) {
+                z = false;
+            } else {
+                sb.append(charSequence);
+            }
+            sb.append(obj);
+        }
+        return sb.toString();
+    }
+
+    public static boolean isToday(long j) {
+        return j / SignalManager.TWENTY_FOUR_HOURS_MILLIS == System.currentTimeMillis() / SignalManager.TWENTY_FOUR_HOURS_MILLIS;
+    }
+}

decompiled/sources/com/helpshift/util/ValueListener.java

@@ -0,0 +1,6 @@
+package com.helpshift.util;
+
+/* loaded from: classes3.dex */
+public interface ValueListener {
+    void update(Object obj);
+}

decompiled/sources/com/helpshift/util/ValuePair.java

@@ -0,0 +1,12 @@
+package com.helpshift.util;
+
+/* loaded from: classes3.dex */
+public class ValuePair {
+    public final Object first;
+    public final Object second;
+
+    public ValuePair(Object obj, Object obj2) {
+        this.first = obj;
+        this.second = obj2;
+    }
+}

decompiled/sources/com/helpshift/util/ViewUtil.java

@@ -0,0 +1,40 @@
+package com.helpshift.util;
+
+import android.app.Activity;
+import android.graphics.Color;
+import android.view.View;
+import android.webkit.ValueCallback;
+import android.webkit.WebView;
+import com.helpshift.log.HSLogger;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes3.dex */
+public abstract class ViewUtil {
+    public static void setVisibility(View view, boolean z) {
+        if (z) {
+            view.setVisibility(0);
+        } else {
+            view.setVisibility(8);
+        }
+    }
+
+    public static void setStatusBarColor(Activity activity, String str) {
+        if (activity != null) {
+            if (Utils.isNotEmpty(str) && Utils.isValidJsonString(str)) {
+                try {
+                    activity.getWindow().setStatusBarColor(Color.parseColor(new JSONObject(str).optString("primaryColor", "#453FB9")));
+                    return;
+                } catch (JSONException e) {
+                    HSLogger.e("ViewUtil", "Error setting status bar color", e);
+                    return;
+                }
+            }
+            activity.getWindow().setStatusBarColor(Color.parseColor("#453FB9"));
+        }
+    }
+
+    public static void callJavascriptCode(WebView webView, String str, ValueCallback valueCallback) {
+        webView.evaluateJavascript(str, valueCallback);
+    }
+}

decompiled/sources/com/helpshift/util/network/connectivity/HSAndroidConnectivityManager.java

@@ -0,0 +1,10 @@
+package com.helpshift.util.network.connectivity;
+
+/* loaded from: classes3.dex */
+public interface HSAndroidConnectivityManager {
+    HSConnectivityStatus getConnectivityStatus();
+
+    void startListeningConnectivityChange(HSNetworkConnectivityCallback hSNetworkConnectivityCallback);
+
+    void stopListeningConnectivityChange();
+}

decompiled/sources/com/helpshift/util/network/connectivity/HSAndroidConnectivityManagerProvider.java

@@ -0,0 +1,10 @@
+package com.helpshift.util.network.connectivity;
+
+import android.content.Context;
+
+/* loaded from: classes3.dex */
+public class HSAndroidConnectivityManagerProvider {
+    public HSAndroidConnectivityManager getOSConnectivityManager(Context context) {
+        return new HSOnAndAboveNConnectivityManager(context);
+    }
+}

decompiled/sources/com/helpshift/util/network/connectivity/HSConnectivityManager.java

@@ -0,0 +1,108 @@
+package com.helpshift.util.network.connectivity;
+
+import android.content.Context;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public class HSConnectivityManager implements HSNetworkConnectivityCallback {
+    public static HSConnectivityManager instance;
+    public Context context;
+    public HSAndroidConnectivityManager hsAndroidConnectivityManager;
+    public Set connectivityCallbacks = Collections.synchronizedSet(new LinkedHashSet());
+    public HSAndroidConnectivityManagerProvider hsAndroidConnectivityManagerProvider = new HSAndroidConnectivityManagerProvider();
+
+    public HSConnectivityManager(Context context) {
+        this.context = context;
+    }
+
+    public static HSConnectivityManager getInstance(Context context) {
+        if (instance == null) {
+            instance = new HSConnectivityManager(context);
+        }
+        return instance;
+    }
+
+    public synchronized void registerNetworkConnectivityListener(HSNetworkConnectivityCallback hSNetworkConnectivityCallback) {
+        try {
+            boolean isEmpty = this.connectivityCallbacks.isEmpty();
+            this.connectivityCallbacks.add(hSNetworkConnectivityCallback);
+            if (isEmpty) {
+                startListenNetworkStatus();
+            } else {
+                int i = AnonymousClass1.$SwitchMap$com$helpshift$util$network$connectivity$HSConnectivityStatus[this.hsAndroidConnectivityManager.getConnectivityStatus().ordinal()];
+                if (i == 1) {
+                    hSNetworkConnectivityCallback.onNetworkAvailable();
+                } else if (i == 2) {
+                    hSNetworkConnectivityCallback.onNetworkUnavailable();
+                }
+            }
+        } finally {
+        }
+    }
+
+    /* renamed from: com.helpshift.util.network.connectivity.HSConnectivityManager$1, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass1 {
+        public static final /* synthetic */ int[] $SwitchMap$com$helpshift$util$network$connectivity$HSConnectivityStatus;
+
+        static {
+            int[] iArr = new int[HSConnectivityStatus.values().length];
+            $SwitchMap$com$helpshift$util$network$connectivity$HSConnectivityStatus = iArr;
+            try {
+                iArr[HSConnectivityStatus.CONNECTED.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$com$helpshift$util$network$connectivity$HSConnectivityStatus[HSConnectivityStatus.NOT_CONNECTED.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+        }
+    }
+
+    public synchronized void unregisterNetworkConnectivityListener(HSNetworkConnectivityCallback hSNetworkConnectivityCallback) {
+        this.connectivityCallbacks.remove(hSNetworkConnectivityCallback);
+        if (this.connectivityCallbacks.isEmpty()) {
+            stopListenNetworkStatus();
+        }
+    }
+
+    public final void startListenNetworkStatus() {
+        if (this.hsAndroidConnectivityManager == null) {
+            this.hsAndroidConnectivityManager = this.hsAndroidConnectivityManagerProvider.getOSConnectivityManager(this.context);
+        }
+        this.hsAndroidConnectivityManager.startListeningConnectivityChange(this);
+    }
+
+    public final void stopListenNetworkStatus() {
+        HSAndroidConnectivityManager hSAndroidConnectivityManager = this.hsAndroidConnectivityManager;
+        if (hSAndroidConnectivityManager == null) {
+            return;
+        }
+        hSAndroidConnectivityManager.stopListeningConnectivityChange();
+        this.hsAndroidConnectivityManager = null;
+    }
+
+    @Override // com.helpshift.util.network.connectivity.HSNetworkConnectivityCallback
+    public void onNetworkAvailable() {
+        if (this.connectivityCallbacks.isEmpty()) {
+            return;
+        }
+        Iterator it = this.connectivityCallbacks.iterator();
+        while (it.hasNext()) {
+            ((HSNetworkConnectivityCallback) it.next()).onNetworkAvailable();
+        }
+    }
+
+    @Override // com.helpshift.util.network.connectivity.HSNetworkConnectivityCallback
+    public void onNetworkUnavailable() {
+        if (this.connectivityCallbacks.isEmpty()) {
+            return;
+        }
+        Iterator it = this.connectivityCallbacks.iterator();
+        while (it.hasNext()) {
+            ((HSNetworkConnectivityCallback) it.next()).onNetworkUnavailable();
+        }
+    }
+}

decompiled/sources/com/helpshift/util/network/connectivity/HSConnectivityStatus.java

@@ -0,0 +1,8 @@
+package com.helpshift.util.network.connectivity;
+
+/* loaded from: classes3.dex */
+public enum HSConnectivityStatus {
+    UNKNOWN,
+    CONNECTED,
+    NOT_CONNECTED
+}

decompiled/sources/com/helpshift/util/network/connectivity/HSNetworkConnectivityCallback.java

@@ -0,0 +1,8 @@
+package com.helpshift.util.network.connectivity;
+
+/* loaded from: classes3.dex */
+public interface HSNetworkConnectivityCallback {
+    void onNetworkAvailable();
+
+    void onNetworkUnavailable();
+}

decompiled/sources/com/helpshift/util/network/connectivity/HSOnAndAboveNConnectivityManager.java

@@ -0,0 +1,91 @@
+package com.helpshift.util.network.connectivity;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import com.helpshift.log.HSLogger;
+
+/* loaded from: classes3.dex */
+public class HSOnAndAboveNConnectivityManager extends ConnectivityManager.NetworkCallback implements HSAndroidConnectivityManager {
+    public Context context;
+    public HSNetworkConnectivityCallback networkListener;
+
+    public HSOnAndAboveNConnectivityManager(Context context) {
+        this.context = context;
+    }
+
+    @Override // com.helpshift.util.network.connectivity.HSAndroidConnectivityManager
+    public void startListeningConnectivityChange(HSNetworkConnectivityCallback hSNetworkConnectivityCallback) {
+        this.networkListener = hSNetworkConnectivityCallback;
+        ConnectivityManager connectivityManager = getConnectivityManager();
+        if (connectivityManager != null) {
+            try {
+                connectivityManager.registerDefaultNetworkCallback(this);
+            } catch (Exception e) {
+                HSLogger.e("AboveNConnectvtManager", "Exception while registering network callback", e);
+            }
+        }
+        if (getConnectivityStatus() == HSConnectivityStatus.NOT_CONNECTED) {
+            hSNetworkConnectivityCallback.onNetworkUnavailable();
+        }
+    }
+
+    @Override // com.helpshift.util.network.connectivity.HSAndroidConnectivityManager
+    public void stopListeningConnectivityChange() {
+        ConnectivityManager connectivityManager = getConnectivityManager();
+        if (connectivityManager != null) {
+            try {
+                connectivityManager.unregisterNetworkCallback(this);
+            } catch (Exception e) {
+                HSLogger.e("AboveNConnectvtManager", "Exception while unregistering network callback", e);
+            }
+        }
+        this.networkListener = null;
+    }
+
+    @Override // com.helpshift.util.network.connectivity.HSAndroidConnectivityManager
+    public HSConnectivityStatus getConnectivityStatus() {
+        HSConnectivityStatus hSConnectivityStatus = HSConnectivityStatus.UNKNOWN;
+        ConnectivityManager connectivityManager = getConnectivityManager();
+        if (connectivityManager == null) {
+            return hSConnectivityStatus;
+        }
+        if (connectivityManager.getActiveNetwork() != null) {
+            return HSConnectivityStatus.CONNECTED;
+        }
+        return HSConnectivityStatus.NOT_CONNECTED;
+    }
+
+    @Override // android.net.ConnectivityManager.NetworkCallback
+    public void onAvailable(Network network) {
+        HSNetworkConnectivityCallback hSNetworkConnectivityCallback = this.networkListener;
+        if (hSNetworkConnectivityCallback != null) {
+            hSNetworkConnectivityCallback.onNetworkAvailable();
+        }
+    }
+
+    @Override // android.net.ConnectivityManager.NetworkCallback
+    public void onLost(Network network) {
+        HSNetworkConnectivityCallback hSNetworkConnectivityCallback = this.networkListener;
+        if (hSNetworkConnectivityCallback != null) {
+            hSNetworkConnectivityCallback.onNetworkUnavailable();
+        }
+    }
+
+    @Override // android.net.ConnectivityManager.NetworkCallback
+    public void onUnavailable() {
+        HSNetworkConnectivityCallback hSNetworkConnectivityCallback = this.networkListener;
+        if (hSNetworkConnectivityCallback != null) {
+            hSNetworkConnectivityCallback.onNetworkUnavailable();
+        }
+    }
+
+    private ConnectivityManager getConnectivityManager() {
+        try {
+            return (ConnectivityManager) this.context.getSystemService("connectivity");
+        } catch (Exception e) {
+            HSLogger.e("AboveNConnectvtManager", "Exception while getting connectivity manager", e);
+            return null;
+        }
+    }
+}