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/csdk/glucustomersupport/BuildConfig.java

@@ -0,0 +1,9 @@
+package csdk.glucustomersupport;
+
+/* loaded from: classes4.dex */
+public final class BuildConfig {
+    public static final String BUILD_TYPE = "release";
+    public static final boolean DEBUG = false;
+    public static final String LIBRARY_PACKAGE_NAME = "csdk.glucustomersupport";
+    public static final String VERSION_NAME = "3.2.0-f80367e";
+}

decompiled/sources/csdk/glucustomersupport/Consts.java

@@ -0,0 +1,15 @@
+package csdk.glucustomersupport;
+
+/* loaded from: classes4.dex */
+public class Consts {
+    public static final String LOGIN_INFO_EMAIL = "GCC_LOGIN_INFO_EMAIL";
+    public static final String LOGIN_INFO_JWT_TOKEN = "GCC_LOGIN_INFO_JWT_TOKEN";
+    public static final String LOGIN_INFO_NAME = "GCC_LOGIN_INFO_NAME";
+    public static final String LOGIN_INFO_USERID = "GCC_LOGIN_INFO_USERID";
+    public static final String SDK_GLU_CUSTOMERSUPPORT = "gluCustomerSupport";
+    public static final String SHOW_OPTION_FAQ_ID = "GCC_SHOW_OPTION_FAQ_ID";
+    public static final String SHOW_OPTION_FAQ_SECTION = "GCC_SHOW_OPTION_FAQ_SECTION";
+    public static final String SHOW_TYPE_CHAT = "GCC_SHOW_TYPE_CHAT";
+    public static final String SHOW_TYPE_DEFAULT = "GCC_SHOW_TYPE_DEFAULT";
+    public static final String SHOW_TYPE_FAQ = "GCC_SHOW_TYPE_FAQ";
+}

decompiled/sources/csdk/glucustomersupport/GluCustomerSupportSessionEndedEvent.java

@@ -0,0 +1,20 @@
+package csdk.glucustomersupport;
+
+import csdk.glucustomersupport.util.ISerializableJsonObject;
+import csdk.glucustomersupport.util.JsonUtil;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class GluCustomerSupportSessionEndedEvent implements ISerializableJsonObject {
+    public final Throwable error;
+
+    public GluCustomerSupportSessionEndedEvent(Throwable th) {
+        this.error = th;
+    }
+
+    @Override // csdk.glucustomersupport.util.ISerializableJsonObject
+    public void write(JSONStringer jSONStringer) throws JSONException {
+        JsonUtil.optKeyValue(jSONStringer, "error", this.error);
+    }
+}

decompiled/sources/csdk/glucustomersupport/GluCustomerSupportSessionStartedEvent.java

@@ -0,0 +1,20 @@
+package csdk.glucustomersupport;
+
+import csdk.glucustomersupport.util.ISerializableJsonObject;
+import csdk.glucustomersupport.util.JsonUtil;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class GluCustomerSupportSessionStartedEvent implements ISerializableJsonObject {
+    public final Throwable error;
+
+    public GluCustomerSupportSessionStartedEvent(Throwable th) {
+        this.error = th;
+    }
+
+    @Override // csdk.glucustomersupport.util.ISerializableJsonObject
+    public void write(JSONStringer jSONStringer) throws JSONException {
+        JsonUtil.optKeyValue(jSONStringer, "error", this.error);
+    }
+}

decompiled/sources/csdk/glucustomersupport/GluFactory.java

@@ -0,0 +1,66 @@
+package csdk.glucustomersupport;
+
+import android.app.Activity;
+import com.facebook.share.internal.ShareConstants;
+import com.ironsource.nb;
+import csdk.glucustomersupport.eventbus.GluConfigEventHandler;
+import csdk.glucustomersupport.eventbus.GluEventBus;
+import csdk.glucustomersupport.eventbus.GluEventHandler;
+import csdk.glucustomersupport.impl.GluDummyImpl;
+import csdk.glucustomersupport.impl.GluHelpshift;
+import csdk.glucustomersupport.impl.GluImplWrapper;
+import csdk.glucustomersupport.util.ConfigUtil;
+import csdk.glucustomersupport.util.GluUtil;
+import csdk.glucustomersupport.util.IAction2;
+import csdk.glucustomersupport.util.JsonUtil;
+import csdk.glucustomersupport.util.StringStore;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class GluFactory {
+    public IGluCustomerSupport createCustomerSupport(final Callable<Activity> callable, String str, Map<String, Object> map) {
+        final GluImplWrapper gluImplWrapper = new GluImplWrapper();
+        final Map shallowClone = GluUtil.shallowClone(map);
+        try {
+            GluConfigEventHandler.request(str, JsonUtil.parseJsonObject(str), new IAction2<String, String>() { // from class: csdk.glucustomersupport.GluFactory.1
+                @Override // csdk.glucustomersupport.util.IAction2
+                public void apply(String str2, String str3) {
+                    try {
+                        Map<String, Object> parseJsonObject = JsonUtil.parseJsonObject(str2);
+                        boolean z = ConfigUtil.getBoolean(parseJsonObject, "csdk.gluCustomerSupport.debug.all", false);
+                        Object[] objArr = new Object[4];
+                        objArr[0] = "sdk";
+                        objArr[1] = Consts.SDK_GLU_CUSTOMERSUPPORT;
+                        objArr[2] = ShareConstants.FEED_SOURCE_PARAM;
+                        objArr[3] = str3 != null ? str3.toUpperCase(Locale.US) : null;
+                        GluUtil.log(z, "CONFIG.RECONFIGURE", objArr);
+                        gluImplWrapper.setImpl(GluFactory.this.createInternal(callable, parseJsonObject, shallowClone, z));
+                    } catch (JSONException e) {
+                        throw GluUtil.propagate(e);
+                    }
+                }
+            });
+            return gluImplWrapper;
+        } catch (JSONException e) {
+            throw GluUtil.propagate(e);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public IGluCustomerSupport createInternal(Callable<Activity> callable, Map<String, Object> map, Map<String, Object> map2, boolean z) {
+        GluUtil.log(z, "SDK.VERSION", nb.q, Consts.SDK_GLU_CUSTOMERSUPPORT, csdk.gluads.Consts.KEY_TAPJOY_USER_ID_VERSION, BuildConfig.VERSION_NAME);
+        if (ConfigUtil.getBoolean(map, "csdk.disabled.gluCustomerSupport", false)) {
+            return new GluDummyImpl();
+        }
+        StringStore.init();
+        GluHelpshift gluHelpshift = ConfigUtil.getString(map, "csdk.gluCustomerSupport.provider", "helpshift").equals("kustomer") ? null : new GluHelpshift(callable, map, map2);
+        if (gluHelpshift == null) {
+            return new GluDummyImpl();
+        }
+        gluHelpshift.init(GluEventHandler.subscribe(ConfigUtil.getBoolean(map, "csdk.gluCustomerSupport.disabled.eventBus", false) ? GluEventBus.DISCONNECTED : GluEventBus.SHARED, GluEventBus.GLOBAL_TOKEN, gluHelpshift));
+        return gluHelpshift;
+    }
+}

decompiled/sources/csdk/glucustomersupport/IGluCustomerSupport.java

@@ -0,0 +1,32 @@
+package csdk.glucustomersupport;
+
+import csdk.glucustomersupport.eventbus.GluEventHandler;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface IGluCustomerSupport {
+    void close();
+
+    void destroy();
+
+    void init(GluEventHandler gluEventHandler);
+
+    void login(Map<String, Object> map);
+
+    void logout();
+
+    void queryNotificationCount();
+
+    void setConsentFlags(Map<String, ?> map);
+
+    void setLanguageCode(String str);
+
+    void setListener(IGluCustomerSupportListener iGluCustomerSupportListener);
+
+    void setMetadata(Map<String, Object> map, List<Object> list, Map<String, Object> map2);
+
+    void setPushToken(String str);
+
+    void show(String str, Map<String, Object> map);
+}

decompiled/sources/csdk/glucustomersupport/IGluCustomerSupportListener.java

@@ -0,0 +1,10 @@
+package csdk.glucustomersupport;
+
+/* loaded from: classes4.dex */
+public interface IGluCustomerSupportListener {
+    void onHelpshiftSessionEnded(GluCustomerSupportSessionEndedEvent gluCustomerSupportSessionEndedEvent);
+
+    void onHelpshiftSessionStarted(GluCustomerSupportSessionStartedEvent gluCustomerSupportSessionStartedEvent);
+
+    void onQueryNotificationCount(NotificationCountEvent notificationCountEvent);
+}

decompiled/sources/csdk/glucustomersupport/NativeBridge.java

@@ -0,0 +1,106 @@
+package csdk.glucustomersupport;
+
+import android.app.Activity;
+import csdk.glucustomersupport.util.GluUtil;
+import java.lang.ref.WeakReference;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes4.dex */
+public class NativeBridge implements IGluCustomerSupportListener {
+    private WeakReference<Activity> mActivity;
+    private long mNativeData;
+
+    private static native void destroy(long j);
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static native Activity getCurrentActivity(long j);
+
+    private static native void onHelpshiftSessionEnded(long j, String str);
+
+    private static native void onHelpshiftSessionStarted(long j, String str);
+
+    private static native void onQueryNotificationCount(long j, long j2, String str);
+
+    public NativeBridge(long j) {
+        this.mNativeData = j;
+        this.mActivity = new WeakReference<>(getCurrentActivity(this.mNativeData));
+    }
+
+    public void destroy() {
+        synchronized (this) {
+            try {
+                long j = this.mNativeData;
+                this.mNativeData = 0L;
+                if (j != 0) {
+                    destroy(j);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public IGluCustomerSupport createCustomerSupport(String str, Map<String, Object> map) {
+        IGluCustomerSupport createCustomerSupport = new GluFactory().createCustomerSupport(new Callable<Activity>() { // from class: csdk.glucustomersupport.NativeBridge.1
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // java.util.concurrent.Callable
+            public Activity call() throws Exception {
+                Activity activity;
+                synchronized (NativeBridge.this) {
+                    try {
+                        if (NativeBridge.this.mNativeData != 0) {
+                            NativeBridge.this.mActivity = new WeakReference(NativeBridge.getCurrentActivity(NativeBridge.this.mNativeData));
+                        }
+                        activity = (Activity) NativeBridge.this.mActivity.get();
+                    } catch (Throwable th) {
+                        throw th;
+                    }
+                }
+                return activity;
+            }
+        }, GluUtil.emptyToNull(str), map);
+        createCustomerSupport.setListener(this);
+        return createCustomerSupport;
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupportListener
+    public void onQueryNotificationCount(NotificationCountEvent notificationCountEvent) {
+        synchronized (this) {
+            try {
+                long j = this.mNativeData;
+                long j2 = notificationCountEvent.count;
+                Throwable th = notificationCountEvent.error;
+                onQueryNotificationCount(j, j2, th != null ? th.getMessage() : null);
+            } catch (Throwable th2) {
+                throw th2;
+            }
+        }
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupportListener
+    public void onHelpshiftSessionStarted(GluCustomerSupportSessionStartedEvent gluCustomerSupportSessionStartedEvent) {
+        synchronized (this) {
+            try {
+                long j = this.mNativeData;
+                Throwable th = gluCustomerSupportSessionStartedEvent.error;
+                onHelpshiftSessionStarted(j, th != null ? th.getMessage() : null);
+            } catch (Throwable th2) {
+                throw th2;
+            }
+        }
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupportListener
+    public void onHelpshiftSessionEnded(GluCustomerSupportSessionEndedEvent gluCustomerSupportSessionEndedEvent) {
+        synchronized (this) {
+            try {
+                long j = this.mNativeData;
+                Throwable th = gluCustomerSupportSessionEndedEvent.error;
+                onHelpshiftSessionEnded(j, th != null ? th.getMessage() : null);
+            } catch (Throwable th2) {
+                throw th2;
+            }
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/NotificationCountEvent.java

@@ -0,0 +1,23 @@
+package csdk.glucustomersupport;
+
+import csdk.glucustomersupport.util.ISerializableJsonObject;
+import csdk.glucustomersupport.util.JsonUtil;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class NotificationCountEvent implements ISerializableJsonObject {
+    public final int count;
+    public final Throwable error;
+
+    public NotificationCountEvent(int i, Throwable th) {
+        this.count = i;
+        this.error = th;
+    }
+
+    @Override // csdk.glucustomersupport.util.ISerializableJsonObject
+    public void write(JSONStringer jSONStringer) throws JSONException {
+        JsonUtil.optKeyValue(jSONStringer, "count", Integer.valueOf(this.count));
+        JsonUtil.optKeyValue(jSONStringer, "error", this.error);
+    }
+}

decompiled/sources/csdk/glucustomersupport/eventbus/GluConfigEventHandler.java

@@ -0,0 +1,93 @@
+package csdk.glucustomersupport.eventbus;
+
+import android.text.TextUtils;
+import com.facebook.share.internal.ShareConstants;
+import com.mbridge.msdk.MBridgeConstans;
+import csdk.glucustomersupport.eventbus.GluEventBus;
+import csdk.glucustomersupport.util.ConfigUtil;
+import csdk.glucustomersupport.util.GluUtil;
+import csdk.glucustomersupport.util.IAction2;
+import java.util.Collections;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class GluConfigEventHandler implements GluEventBus.IEventHandler {
+    private static final String CHANNEL_SDK = "#csdk.gluCustomerSupport";
+    private static final String EVENT_SDK = "#csdk.gluCustomerSupport.evt";
+    private static final String ID_HANDLER = "@csdk.gluCustomerSupport.configGetter";
+    private final String mDefaultConfig;
+    private final GluEventBus mEventBus;
+    private final IAction2<String, String> mInitFn;
+    private Object mToken;
+    private boolean mut_initialized;
+
+    private GluConfigEventHandler(GluEventBus gluEventBus, IAction2<String, String> iAction2, String str) {
+        this.mEventBus = gluEventBus;
+        this.mInitFn = iAction2;
+        this.mDefaultConfig = str;
+    }
+
+    private static GluConfigEventHandler subscribe(GluEventBus gluEventBus, Object obj, IAction2<String, String> iAction2, String str) {
+        GluConfigEventHandler gluConfigEventHandler = new GluConfigEventHandler(gluEventBus, iAction2, str);
+        gluConfigEventHandler.mToken = gluEventBus.subscribe(obj, ID_HANDLER, Collections.singletonList(CHANNEL_SDK), gluConfigEventHandler);
+        return gluConfigEventHandler;
+    }
+
+    public static void request(String str, Map<String, Object> map, IAction2<String, String> iAction2) {
+        boolean z = ConfigUtil.getBoolean(map, "csdk.gluCustomerSupport.disabled.configUpdate", false);
+        long j = (long) (ConfigUtil.getDouble(map, "csdk.gluCustomerSupport.configUpdate.timeoutInSec", 5.0d) * 1000.0d);
+        GluEventBus gluEventBus = ConfigUtil.getBoolean(map, "csdk.gluCustomerSupport.disabled.eventBus", false) ? GluEventBus.DISCONNECTED : GluEventBus.SHARED;
+        if (gluEventBus.isConnected() && !z) {
+            subscribe(gluEventBus, GluEventBus.GLOBAL_TOKEN, iAction2, str).requestConfig(j);
+        } else {
+            iAction2.apply(str, "APP-NO-EB");
+        }
+    }
+
+    public void requestConfig(long j) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(EVENT_SDK, "configRequested", null, Collections.singletonMap("jsonConfig", this.mDefaultConfig)));
+        if (j > 0) {
+            GluUtil.runOnUIThreadDelayed(new Runnable() { // from class: csdk.glucustomersupport.eventbus.GluConfigEventHandler.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    GluConfigEventHandler gluConfigEventHandler = GluConfigEventHandler.this;
+                    gluConfigEventHandler.initOnce(gluConfigEventHandler.mDefaultConfig, "app-timeout");
+                    GluConfigEventHandler.this.onDestroy();
+                }
+            }, j);
+        }
+    }
+
+    public void onDestroy() {
+        this.mEventBus.unsubscribe(this.mToken);
+    }
+
+    @Override // csdk.glucustomersupport.eventbus.GluEventBus.IEventHandler
+    public void handleEvent(GluEventBus gluEventBus, Object obj, String str, GluEventBus.Event event) throws Exception {
+        String str2;
+        if (TextUtils.equals(event.channel, CHANNEL_SDK) && TextUtils.equals(event.action, "reconfigure")) {
+            String string = ConfigUtil.getString(event.data, "jsonConfig");
+            if (TextUtils.isEmpty(string)) {
+                string = this.mDefaultConfig;
+                str2 = MBridgeConstans.DYNAMIC_VIEW_WX_APP;
+            } else {
+                str2 = ConfigUtil.getString(event.data, ShareConstants.FEED_SOURCE_PARAM);
+            }
+            initOnce(string, str2);
+            gluEventBus.unsubscribe(obj);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void initOnce(String str, String str2) {
+        boolean z;
+        synchronized (this) {
+            z = this.mut_initialized;
+            this.mut_initialized = true;
+        }
+        if (z) {
+            return;
+        }
+        this.mInitFn.apply(str, str2);
+    }
+}

decompiled/sources/csdk/glucustomersupport/eventbus/GluEventBus.java

@@ -0,0 +1,246 @@
+package csdk.glucustomersupport.eventbus;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import csdk.glucentralservices.eventbus.IServerEventBus;
+import csdk.glucentralservices.eventbus.IServerEventHandler;
+import csdk.glucentralservices.eventbus.ServerEventBus;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+public abstract class GluEventBus {
+    public static final GluEventBus DISCONNECTED = new DisconnectedEventBus();
+    private static final String EVT_ACTION = "action";
+    private static final String EVT_CHANNEL = "channel";
+    private static final String EVT_DATA = "data";
+    private static final String EVT_SENDER = "sender";
+    public static final Object GLOBAL_TOKEN;
+    private static final Set<String> KEYS;
+    public static final GluEventBus SHARED;
+
+    public interface IEventHandler {
+        void handleEvent(GluEventBus gluEventBus, Object obj, String str, Event event) throws Exception;
+    }
+
+    public abstract Object globalToken();
+
+    public abstract boolean isConnected();
+
+    public abstract void publish(Object obj, Event event);
+
+    public abstract Object subscribe(Object obj, String str, Collection<String> collection, IEventHandler iEventHandler);
+
+    public abstract void unsubscribe(Object obj);
+
+    static {
+        GluEventBus createEventBus = createEventBus();
+        SHARED = createEventBus;
+        GLOBAL_TOKEN = createEventBus.globalToken();
+        KEYS = createKeys();
+    }
+
+    private static GluEventBus createEventBus() {
+        try {
+            return new RealEventBus(ServerEventBus.getShared());
+        } catch (NoClassDefFoundError unused) {
+            return DISCONNECTED;
+        }
+    }
+
+    private static Set<String> createKeys() {
+        HashSet hashSet = new HashSet();
+        hashSet.add("channel");
+        hashSet.add("action");
+        hashSet.add(EVT_SENDER);
+        hashSet.add("data");
+        return hashSet;
+    }
+
+    public static class Event implements Map<String, Object> {
+        public String action;
+        public String channel;
+        public Map<String, Object> data;
+        public String sender;
+
+        public Event() {
+        }
+
+        public Event(String str, String str2, String str3, Map<String, Object> map) {
+            this.channel = str;
+            this.action = str2;
+            this.sender = str3;
+            this.data = map;
+        }
+
+        @Override // java.util.Map
+        public int size() {
+            return keySet().size();
+        }
+
+        @Override // java.util.Map
+        public boolean isEmpty() {
+            return size() == 0;
+        }
+
+        @Override // java.util.Map
+        public boolean containsKey(Object obj) {
+            return GluEventBus.KEYS.contains(obj);
+        }
+
+        @Override // java.util.Map
+        public boolean containsValue(Object obj) {
+            return values().contains(obj);
+        }
+
+        @Override // java.util.Map
+        public Object get(Object obj) {
+            if (obj == null) {
+                return null;
+            }
+            if (obj.equals("channel")) {
+                return this.channel;
+            }
+            if (obj.equals("action")) {
+                return this.action;
+            }
+            if (obj.equals(GluEventBus.EVT_SENDER)) {
+                return this.sender;
+            }
+            if (obj.equals("data")) {
+                return this.data;
+            }
+            return null;
+        }
+
+        @Override // java.util.Map
+        public Object put(String str, Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public Object remove(Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public void putAll(@NonNull Map<? extends String, ? extends Object> map) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public void clear() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Set<String> keySet() {
+            return GluEventBus.KEYS;
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Collection<Object> values() {
+            return Arrays.asList(this.channel, this.action, this.sender, this.data);
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Set<Map.Entry<String, Object>> entrySet() {
+            HashSet hashSet = new HashSet();
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("channel", this.channel));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("action", this.action));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry(GluEventBus.EVT_SENDER, this.sender));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("data", this.data));
+            return hashSet;
+        }
+    }
+
+    public static class DisconnectedEventBus extends GluEventBus {
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public Object globalToken() {
+            return this;
+        }
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public boolean isConnected() {
+            return false;
+        }
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+        }
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+        }
+
+        private DisconnectedEventBus() {
+        }
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public Object subscribe(Object obj, String str, Collection<String> collection, IEventHandler iEventHandler) {
+            if (iEventHandler != null) {
+                try {
+                    iEventHandler.handleEvent(this, obj, str, new Event("#me", "unsubscribed", "@eb.disconnected", null));
+                } catch (Exception e) {
+                    Log.e("DisconnectedEventBus", "Failed to destroy handler", e);
+                }
+            }
+            return null;
+        }
+    }
+
+    public static class RealEventBus extends GluEventBus {
+        private final IServerEventBus mEventBus;
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public boolean isConnected() {
+            return true;
+        }
+
+        public RealEventBus(IServerEventBus iServerEventBus) {
+            this.mEventBus = iServerEventBus;
+        }
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public Object subscribe(Object obj, String str, Collection<String> collection, final IEventHandler iEventHandler) {
+            return this.mEventBus.subscribe(obj, str, collection, iEventHandler != null ? new IServerEventHandler() { // from class: csdk.glucustomersupport.eventbus.GluEventBus.RealEventBus.1
+                @Override // csdk.glucentralservices.eventbus.IServerEventHandler
+                public void handleEvent(IServerEventBus iServerEventBus, Object obj2, String str2, Map<String, Object> map) throws Exception {
+                    Event event;
+                    if (map != null) {
+                        event = new Event();
+                        event.channel = (String) map.get("channel");
+                        event.action = (String) map.get("action");
+                        event.sender = (String) map.get(GluEventBus.EVT_SENDER);
+                        event.data = (Map) map.get("data");
+                    } else {
+                        event = null;
+                    }
+                    iEventHandler.handleEvent(RealEventBus.this, obj2, str2, event);
+                }
+            } : null);
+        }
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+            this.mEventBus.unsubscribe(obj);
+        }
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+            this.mEventBus.publish(obj, event);
+        }
+
+        @Override // csdk.glucustomersupport.eventbus.GluEventBus
+        public Object globalToken() {
+            return this.mEventBus.globalToken();
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/eventbus/GluEventHandler.java

@@ -0,0 +1,72 @@
+package csdk.glucustomersupport.eventbus;
+
+import csdk.glucustomersupport.IGluCustomerSupport;
+import csdk.glucustomersupport.eventbus.GluEventBus;
+import csdk.glucustomersupport.util.ConfigUtil;
+import csdk.glucustomersupport.util.GluUtil;
+import java.util.Arrays;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class GluEventHandler implements GluEventBus.IEventHandler {
+    private static final String CHANNEL_LIFECYCLE_EVT = "#lifecycle.evt";
+    private static final String CHANNEL_SDK = "#csdk.gluCustomerSupport";
+    private static final String CHANNEL_SDK_EVT = "#csdk.gluCustomerSupport.evt";
+    private static final String ID_HANDLER = "@csdk.gluCustomerSupport";
+    private final GluEventBus mEventBus;
+    private final IGluCustomerSupport mInstance;
+    private Object mToken;
+
+    public static GluEventHandler subscribe(GluEventBus gluEventBus, Object obj, IGluCustomerSupport iGluCustomerSupport) {
+        GluEventHandler gluEventHandler = new GluEventHandler(gluEventBus, iGluCustomerSupport);
+        gluEventHandler.mToken = gluEventBus.subscribe(obj, ID_HANDLER, Arrays.asList(CHANNEL_SDK, CHANNEL_LIFECYCLE_EVT), gluEventHandler);
+        return gluEventHandler;
+    }
+
+    private GluEventHandler(GluEventBus gluEventBus, IGluCustomerSupport iGluCustomerSupport) {
+        this.mEventBus = gluEventBus;
+        this.mInstance = iGluCustomerSupport;
+    }
+
+    public void sendAnalyticsEvent(String str, Map<String, Object> map) {
+        Map createMap = GluUtil.createMap();
+        createMap.put("st2", str);
+        createMap.put("data", map);
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#csdk.gluCentralServices.evt", "logCareEvent", null, createMap));
+    }
+
+    public void onInit(String str) {
+        Map createMap = GluUtil.createMap();
+        createMap.put("name", "GluCustomerSupport");
+        createMap.put("version", str);
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#sdk.evt", "initialized", null, createMap));
+    }
+
+    public void onDestroy() {
+        Map createMap = GluUtil.createMap();
+        createMap.put("name", "GluCustomerSupport");
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#sdk.evt", "destroyed", null, createMap));
+        this.mEventBus.unsubscribe(this.mToken);
+    }
+
+    @Override // csdk.glucustomersupport.eventbus.GluEventBus.IEventHandler
+    public void handleEvent(GluEventBus gluEventBus, Object obj, String str, GluEventBus.Event event) {
+        Map<String, ?> map = event.data;
+        if (CHANNEL_SDK.equals(event.channel)) {
+            String str2 = event.action;
+            str2.hashCode();
+            switch (str2) {
+                case "updateGDPRConsentStatus":
+                    this.mInstance.setConsentFlags(map);
+                    return;
+                case "setPushToken":
+                    this.mInstance.setPushToken(ConfigUtil.getString(map, "val"));
+                    return;
+                case "destroy":
+                    return;
+                default:
+                    throw new UnsupportedOperationException();
+            }
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/impl/GluDummyImpl.java

@@ -0,0 +1,58 @@
+package csdk.glucustomersupport.impl;
+
+import csdk.glucustomersupport.IGluCustomerSupport;
+import csdk.glucustomersupport.IGluCustomerSupportListener;
+import csdk.glucustomersupport.eventbus.GluEventHandler;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class GluDummyImpl implements IGluCustomerSupport {
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void close() {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void destroy() {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void init(GluEventHandler gluEventHandler) {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void login(Map<String, Object> map) {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void logout() {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void queryNotificationCount() {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setConsentFlags(Map<String, ?> map) {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setLanguageCode(String str) {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setListener(IGluCustomerSupportListener iGluCustomerSupportListener) {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setMetadata(Map<String, Object> map, List<Object> list, Map<String, Object> map2) {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setPushToken(String str) {
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void show(String str, Map<String, Object> map) {
+    }
+}

decompiled/sources/csdk/glucustomersupport/impl/GluHelpShiftActivityLifecycleCallbacks.java

@@ -0,0 +1,90 @@
+package csdk.glucustomersupport.impl;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.os.Bundle;
+import csdk.glucustomersupport.util.GluUtil;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+public class GluHelpShiftActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
+    public static final String APPLICATION_PAUSE = "onApplicationPaused";
+    public static final String APPLICATION_RESUME = "onApplicationResumed";
+    private Set<Activity> mActivities;
+    private Application mApplication;
+    private IAction2<String, Activity> mOnActivityCallback;
+
+    public boolean isRunning() {
+        return this.mApplication != null;
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityDestroyed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityResumed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+    }
+
+    public GluHelpShiftActivityLifecycleCallbacks(Context context, IAction2<String, Activity> iAction2) {
+        Context applicationContext = context.getApplicationContext();
+        if (applicationContext instanceof Application) {
+            this.mOnActivityCallback = iAction2;
+            this.mActivities = new HashSet();
+            Application application = (Application) applicationContext;
+            this.mApplication = application;
+            application.registerActivityLifecycleCallbacks(this);
+        }
+    }
+
+    public void destroy() {
+        GluUtil.runOnUIThread(new Runnable() { // from class: csdk.glucustomersupport.impl.GluHelpShiftActivityLifecycleCallbacks.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (GluHelpShiftActivityLifecycleCallbacks.this.mApplication != null) {
+                    GluHelpShiftActivityLifecycleCallbacks.this.mApplication.unregisterActivityLifecycleCallbacks(this);
+                }
+                GluHelpShiftActivityLifecycleCallbacks.this.mApplication = null;
+                GluHelpShiftActivityLifecycleCallbacks.this.mOnActivityCallback = null;
+                GluHelpShiftActivityLifecycleCallbacks.this.mActivities = null;
+            }
+        });
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStarted(Activity activity) {
+        if (this.mOnActivityCallback != null && addActivity(activity) && this.mActivities.size() == 1) {
+            this.mOnActivityCallback.apply("onApplicationResumed", activity);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(Activity activity) {
+        addActivity(activity);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(Activity activity) {
+        if (this.mOnActivityCallback != null && this.mActivities.remove(activity) && this.mActivities.size() == 0) {
+            this.mOnActivityCallback.apply("onApplicationPaused", activity);
+        }
+    }
+
+    private boolean addActivity(Activity activity) {
+        Set<Activity> set = this.mActivities;
+        if (set != null) {
+            return set.add(activity);
+        }
+        return false;
+    }
+}

decompiled/sources/csdk/glucustomersupport/impl/GluHelpshift.java

@@ -0,0 +1,474 @@
+package csdk.glucustomersupport.impl;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.SharedPreferences;
+import android.text.TextUtils;
+import android.util.Pair;
+import androidx.annotation.NonNull;
+import androidx.core.app.NotificationCompat;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.helpshift.Helpshift;
+import com.helpshift.HelpshiftAuthenticationFailureReason;
+import com.helpshift.HelpshiftEventsListener;
+import com.helpshift.core.HSContext;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.tapjoy.TJAdUnitConstants;
+import csdk.gluads.PrivacyStatus;
+import csdk.glucustomersupport.Consts;
+import csdk.glucustomersupport.GluCustomerSupportSessionEndedEvent;
+import csdk.glucustomersupport.GluCustomerSupportSessionStartedEvent;
+import csdk.glucustomersupport.NotificationCountEvent;
+import csdk.glucustomersupport.util.ConfigUtil;
+import csdk.glucustomersupport.util.GluUtil;
+import csdk.glucustomersupport.util.JsonUtil;
+import csdk.glucustomersupport.util.StringStore;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes4.dex */
+public class GluHelpshift extends GluImplBase {
+    List<Object> countriesThatRequireFullPrivacy;
+    private GluHelpShiftActivityLifecycleCallbacks mActivityLifeCycleCallbacks;
+    private boolean mCcpaApplies;
+    HashMap<String, Object> mConfig;
+    private String mDefaultShowType;
+    private boolean mFetchNotificationCountFromServer;
+    private boolean mGdprApplies;
+    private String mPublishID;
+    private boolean mUnderAge;
+    private String pushTokenCopy;
+    private boolean sendAnalyticsEvents;
+
+    public void sendAnalyticsEvent(String str, Map<String, Object> map) {
+        if (this.sendAnalyticsEvents) {
+            if (map == null) {
+                map = new HashMap<>();
+            }
+            String str2 = "C_" + str;
+            String str3 = this.mPublishID;
+            if (str3 != null && str3.length() > 0 && !this.mPublishID.equals("NOT_AVAILABLE")) {
+                map.put("publishID", this.mPublishID);
+            }
+            map.put("tier", Integer.valueOf(this.tier));
+            this.mEventHandler.sendAnalyticsEvent(str2, map);
+        }
+    }
+
+    public GluHelpshift(Callable<Activity> callable, Map<String, Object> map, Map<String, Object> map2) {
+        super(callable, map, "HELPSHIFT");
+        this.mConfig = new HashMap<>();
+        this.mDefaultShowType = ConfigUtil.getString(map, "csdk.gluCustomerSupport.helpshift.defaultShowType", "chat");
+        ConfigUtil.getString(map, "csdk.gluCustomerSupport.helpshift.apiKey", null);
+        String string = ConfigUtil.getString(map, "csdk.gluCustomerSupport.helpshift.domainName", null);
+        String string2 = ConfigUtil.getString(map, "csdk.gluCustomerSupport.helpshift.appID", null);
+        Boolean valueOf = Boolean.valueOf(ConfigUtil.getBoolean(map, "csdk.gluCustomerSupport.helpshift.enableManualLifecycleTracking", false));
+        this.mFetchNotificationCountFromServer = ConfigUtil.getBoolean(map, "csdk.gluCustomerSupport.helpshift.fetchNotificationCountFromServer", true);
+        this.mGdprApplies = false;
+        this.mCcpaApplies = false;
+        this.mUnderAge = false;
+        this.sendAnalyticsEvents = !ConfigUtil.getBoolean(map, "csdk.gluCustomerSupport.disabled.sendAnalyticsEvents", false);
+        ArrayList arrayList = new ArrayList();
+        arrayList.add("RU");
+        this.countriesThatRequireFullPrivacy = ConfigUtil.getList(map, "csdk.gluCustomerSupport.helpshift.countriesThatRequireFullPrivacy", arrayList);
+        try {
+            Map<String, Object> installConfig = getInstallConfig(map2, valueOf.booleanValue());
+            Helpshift.install(this.mActivity.getApplication(), string2, string, installConfig);
+            String string3 = ConfigUtil.getString(map2, "language", null);
+            if (string3 != null && string3.length() == 2) {
+                Helpshift.setLanguage(string3);
+            }
+            internal_cacheConfig(string2, string, installConfig);
+        } catch (Exception e) {
+            log("Exception", e.toString());
+        }
+        Helpshift.setHelpshiftEventsListener(new HelpshiftEventsListener() { // from class: csdk.glucustomersupport.impl.GluHelpshift.1
+            @Override // com.helpshift.HelpshiftEventsListener
+            public void onUserAuthenticationFailure(HelpshiftAuthenticationFailureReason helpshiftAuthenticationFailureReason) {
+            }
+
+            @Override // com.helpshift.HelpshiftEventsListener
+            public void onEventOccurred(@NonNull String str, Map<String, Object> map3) {
+                str.hashCode();
+                switch (str) {
+                    case "helpshiftSessionStarted":
+                        GluHelpshift.this.log(InneractiveMediationDefs.GENDER_MALE, "HelpshiftX session started.");
+                        GluHelpshift.this.sendAnalyticsEvent("SESSION_STARTED", null);
+                        GluHelpshift.this.mListener.onHelpshiftSessionStarted(new GluCustomerSupportSessionStartedEvent(null));
+                        break;
+                    case "messageAdd":
+                        GluHelpshift.this.log(map3.get("body"));
+                        if (map3.get("type").equals("attachment")) {
+                            GluHelpshift.this.log(InneractiveMediationDefs.GENDER_MALE, "user sent an attachment");
+                        }
+                        GluHelpshift.this.sendAnalyticsEvent("MESSAGE_ADD", null);
+                        break;
+                    case "receivedUnreadMessageCount":
+                        GluHelpshift.this.log(InneractiveMediationDefs.GENDER_MALE, "HelpshiftX message count event.");
+                        GluHelpshift.this.mListener.onQueryNotificationCount(new NotificationCountEvent(((Integer) map3.get("count")).intValue(), null));
+                        break;
+                    case "conversationEnd":
+                        GluHelpshift.this.sendAnalyticsEvent("CONVERSATION_ENDED", null);
+                        break;
+                    case "helpshiftSessionEnded":
+                        GluHelpshift.this.log(InneractiveMediationDefs.GENDER_MALE, "HelpshiftX session ended.");
+                        GluHelpshift.this.sendAnalyticsEvent("SESSION_ENDED", null);
+                        GluHelpshift.this.mListener.onHelpshiftSessionEnded(new GluCustomerSupportSessionEndedEvent(null));
+                        break;
+                    case "csatSubmit":
+                        GluHelpshift.this.log(map3.get(CampaignEx.JSON_KEY_STAR));
+                        GluHelpshift.this.log(map3.get("additionalFeedback"));
+                        Map<String, Object> createMap = GluUtil.createMap();
+                        createMap.put(CampaignEx.JSON_KEY_STAR, map3.get(CampaignEx.JSON_KEY_STAR));
+                        GluHelpshift.this.sendAnalyticsEvent("CSAT_SUBMIT", createMap);
+                        break;
+                    case "conversationStart":
+                        GluHelpshift.this.log(map3.get("message"));
+                        GluHelpshift.this.sendAnalyticsEvent("CONVERSATION_START", null);
+                        break;
+                    case "widgetToggle":
+                        GluHelpshift.this.log(map3.get(TJAdUnitConstants.String.VISIBLE));
+                        break;
+                    case "conversationRejected":
+                        GluHelpshift.this.log(InneractiveMediationDefs.GENDER_MALE, "Conversation rejected.");
+                        GluHelpshift.this.sendAnalyticsEvent("CONVERSATION_REJECTED", null);
+                        break;
+                    case "conversationReopened":
+                        GluHelpshift.this.log(InneractiveMediationDefs.GENDER_MALE, "Conversation reopened.");
+                        GluHelpshift.this.sendAnalyticsEvent("CONVERSATION_REOPENED", null);
+                        break;
+                    case "conversationResolved":
+                        GluHelpshift.this.log(InneractiveMediationDefs.GENDER_MALE, "Conversation resolved.");
+                        GluHelpshift.this.sendAnalyticsEvent("CONVERSATION_RESOLVED", null);
+                        break;
+                    case "conversationStatus":
+                        GluHelpshift.this.log(map3.get("latestIssuePublishId"));
+                        GluHelpshift.this.mPublishID = (String) map3.get("latestIssuePublishId");
+                        break;
+                }
+            }
+        });
+        if (valueOf.booleanValue()) {
+            Helpshift.onAppForeground();
+            this.mActivityLifeCycleCallbacks = new GluHelpShiftActivityLifecycleCallbacks(this.mActivity, new IAction2<String, Activity>() { // from class: csdk.glucustomersupport.impl.GluHelpshift.2
+                @Override // csdk.glucustomersupport.impl.IAction2
+                public void apply(String str, Activity activity) {
+                    GluHelpshift.this.log("ACTIVITY", NotificationCompat.CATEGORY_EVENT, str, "activity", activity);
+                    if ("onApplicationResumed".equals(str)) {
+                        Helpshift.onAppForeground();
+                    } else if ("onApplicationPaused".equals(str)) {
+                        Helpshift.onAppBackground();
+                    }
+                }
+            });
+        }
+    }
+
+    private void internal_cacheConfig(String str, String str2, Map<String, Object> map) {
+        SharedPreferences.Editor edit = this.mActivity.getApplication().getSharedPreferences("hs_shared", 0).edit();
+        edit.putString("hs_appID", str);
+        edit.putString("hs_domainName", str2);
+        edit.putString("hs_config", JsonUtil.toJson(map));
+        edit.apply();
+    }
+
+    public static void internal_Install(Application application) {
+        if (application == null || HSContext.verifyInstall()) {
+            return;
+        }
+        SharedPreferences sharedPreferences = application.getSharedPreferences("hs_shared", 0);
+        String string = sharedPreferences.getString("hs_appID", "");
+        String string2 = sharedPreferences.getString("hs_domainName", "");
+        String string3 = sharedPreferences.getString("hs_config", "");
+        if (string.length() <= 0 || string2.length() <= 0 || string3.length() <= 0) {
+            return;
+        }
+        try {
+            Helpshift.install(application, string, string2, JsonUtil.toMap(string3));
+        } catch (Exception unused) {
+        }
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void login(Map<String, Object> map) {
+        String gluImplBase = toString(map.get(Consts.LOGIN_INFO_USERID));
+        String gluImplBase2 = toString(map.get(Consts.LOGIN_INFO_NAME));
+        String gluImplBase3 = toString(map.get(Consts.LOGIN_INFO_EMAIL));
+        GluUtil.require(!TextUtils.isEmpty(gluImplBase), "userID can't be null or empty.");
+        String trim = gluImplBase.trim();
+        if (trim.length() > 750) {
+            trim = trim.substring(0, 750);
+            log(InneractiveMediationDefs.GENDER_MALE, "userID is too long, truncated to 750 chars");
+        }
+        this.mUserID = trim;
+        if (gluImplBase2 != null) {
+            gluImplBase2 = gluImplBase2.trim();
+            if (gluImplBase2.length() > 255) {
+                gluImplBase2 = gluImplBase2.substring(0, 255);
+                log(InneractiveMediationDefs.GENDER_MALE, "userName is too long, truncated to 255 chars");
+            }
+        }
+        if (gluImplBase3 != null) {
+            gluImplBase3 = gluImplBase3.trim();
+        }
+        this.mUserName = gluImplBase2;
+        this.mUserEmail = gluImplBase3;
+        HashMap hashMap = new HashMap();
+        String str = this.mUserID;
+        if (str != null && !TextUtils.isEmpty(str)) {
+            hashMap.put("userId", this.mUserID);
+        }
+        String str2 = this.mUserEmail;
+        if (str2 != null && !TextUtils.isEmpty(str2)) {
+            hashMap.put("userEmail", this.mUserEmail);
+        }
+        String str3 = this.mUserName;
+        if (str3 != null && !TextUtils.isEmpty(str3)) {
+            hashMap.put("userName", this.mUserName);
+        }
+        if (hashMap.size() > 0) {
+            Helpshift.login(hashMap);
+        } else {
+            log(InneractiveMediationDefs.GENDER_MALE, "HelpShift login called with no data, ignoring.");
+        }
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void logout() {
+        Helpshift.logout();
+    }
+
+    @Override // csdk.glucustomersupport.impl.GluImplBase, csdk.glucustomersupport.IGluCustomerSupport
+    public void destroy() {
+        GluHelpShiftActivityLifecycleCallbacks gluHelpShiftActivityLifecycleCallbacks = this.mActivityLifeCycleCallbacks;
+        if (gluHelpShiftActivityLifecycleCallbacks != null) {
+            gluHelpShiftActivityLifecycleCallbacks.destroy();
+        }
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void queryNotificationCount() {
+        log(InneractiveMediationDefs.GENDER_MALE, "queryNotificationCount");
+        Helpshift.requestUnreadMessageCount(this.mFetchNotificationCountFromServer);
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void show(String str, Map<String, Object> map) {
+        str.hashCode();
+        switch (str) {
+            case "GCC_SHOW_TYPE_CHAT":
+                showConversation(map);
+                break;
+            case "GCC_SHOW_TYPE_DEFAULT":
+                if (this.mDefaultShowType.equals("chat")) {
+                    show(Consts.SHOW_TYPE_CHAT, map);
+                    break;
+                } else if (this.mDefaultShowType.equals("faq")) {
+                    show(Consts.SHOW_TYPE_FAQ, map);
+                    break;
+                } else {
+                    log("Unsupported default type", this.mDefaultShowType);
+                    break;
+                }
+            case "GCC_SHOW_TYPE_FAQ":
+                if (map != null && map.containsKey(Consts.SHOW_OPTION_FAQ_ID)) {
+                    showSingleFAQ(toString(map.get(Consts.SHOW_OPTION_FAQ_ID)), map);
+                    break;
+                } else if (map != null && map.containsKey(Consts.SHOW_OPTION_FAQ_SECTION)) {
+                    showFAQSection(toString(map.get(Consts.SHOW_OPTION_FAQ_SECTION)), map);
+                    break;
+                } else {
+                    showFAQs(map);
+                    break;
+                }
+                break;
+            default:
+                log("Unsupported type", str);
+                break;
+        }
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setMetadata(Map<String, Object> map, List<Object> list, Map<String, Object> map2) {
+        log("setMetadata", map, "tags", list);
+        Pair<Map<String, Object>, Set<String>> metadata = getMetadata(map, list);
+        HashMap hashMap = new HashMap();
+        if (map2 != null) {
+            hashMap.putAll(map2);
+        }
+        String str = this.mUserID;
+        if (str != null && str.length() > 0 && !hashMap.containsKey("customer_id")) {
+            HashMap hashMap2 = new HashMap();
+            hashMap2.put("type", "singleline");
+            hashMap2.put("value", this.mUserID);
+            hashMap.put("customer_id", hashMap2);
+        }
+        Map map3 = (Map) metadata.first;
+        map3.put("gdpr_applies", this.mGdprApplies ? "true" : "false");
+        map3.put("ccpa_applies", this.mCcpaApplies ? "true" : "false");
+        HashMap<String, Object> hashMap3 = new HashMap<>();
+        this.mConfig = hashMap3;
+        hashMap3.put("customMetadata", map3);
+        this.mConfig.put("tags", ((Set) metadata.second).toArray());
+        if (hashMap.size() > 0) {
+            this.mConfig.put("customIssueFields", hashMap);
+        }
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setLanguageCode(String str) {
+        log(InneractiveMediationDefs.GENDER_MALE, "setLanguageCode", "code", str);
+        Helpshift.setLanguage(str);
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setPushToken(String str) {
+        this.pushTokenCopy = str;
+        log(InneractiveMediationDefs.GENDER_MALE, "setPushToken");
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setConsentFlags(Map<String, ?> map) {
+        this.mGdprApplies = ConfigUtil.getBoolean(map, PrivacyStatus.GDPR_APPLIES, false);
+        this.mCcpaApplies = ConfigUtil.getBoolean(map, PrivacyStatus.CCPA_APPLIES, false);
+        boolean z = ConfigUtil.getBoolean(map, PrivacyStatus.UNDER_AGE_USER, false);
+        this.mUnderAge = z;
+        if (z || this.pushTokenCopy == null) {
+            return;
+        }
+        log(InneractiveMediationDefs.GENDER_MALE, "setConsentFlags");
+        Helpshift.registerPushToken(this.pushTokenCopy);
+    }
+
+    private void showFAQs(Map<String, Object> map) {
+        log(InneractiveMediationDefs.GENDER_MALE, "showFAQs");
+        Helpshift.showFAQs(this.mActivity, convertOptions(map));
+    }
+
+    private void showSingleFAQ(String str, Map<String, Object> map) {
+        log(InneractiveMediationDefs.GENDER_MALE, "showSingleFAQ", "faq", str);
+        Helpshift.showSingleFAQ(this.mActivity, str, convertOptions(map));
+    }
+
+    private void showFAQSection(String str, Map<String, Object> map) {
+        log(InneractiveMediationDefs.GENDER_MALE, "showFAQSection", "section", str);
+        Helpshift.showFAQSection(this.mActivity, str, convertOptions(map));
+    }
+
+    private void showConversation(Map<String, Object> map) {
+        log(InneractiveMediationDefs.GENDER_MALE, "showConversation");
+        Helpshift.showConversation(this.mActivity, convertOptions(map));
+    }
+
+    private void logUserAction(String str) {
+        log("logUserAction", str);
+        Helpshift.leaveBreadCrumb(str);
+    }
+
+    private void clearUserActions() {
+        log(InneractiveMediationDefs.GENDER_MALE, "clearUserActions");
+        Helpshift.clearBreadCrumbs();
+    }
+
+    private Map<String, Object> getInstallConfig(Map<String, Object> map, boolean z) {
+        Object value;
+        Boolean bool;
+        Integer integer;
+        boolean z2;
+        HashMap hashMap = new HashMap();
+        if (map != null) {
+            for (Map.Entry<String, Object> entry : map.entrySet()) {
+                value = entry.getValue();
+                bool = toBoolean(value);
+                integer = toInteger(value);
+                String key = entry.getKey();
+                key.hashCode();
+                z2 = true;
+                switch (key) {
+                    case "notificationSound":
+                        hashMap.put("notificationSoundId", Integer.valueOf(this.mActivity.getResources().getIdentifier(toString(value), "raw", this.mActivity.getPackageName())));
+                        break;
+                    case "largeNotificationIcon":
+                        hashMap.put("notificationLargeIcon", Integer.valueOf(this.mActivity.getResources().getIdentifier(toString(value), "drawable", this.mActivity.getPackageName())));
+                        break;
+                    case "isForChina":
+                        if (bool != null && !bool.booleanValue()) {
+                            z2 = false;
+                        }
+                        hashMap.put("isForChina", Boolean.valueOf(z2));
+                        break;
+                    case "enableInAppNotification":
+                        if (bool != null && !bool.booleanValue()) {
+                            z2 = false;
+                        }
+                        hashMap.put("enableInAppNotification", Boolean.valueOf(z2));
+                        break;
+                    case "supportNotificationChannelId":
+                        hashMap.put("notificationChannelId", value);
+                        break;
+                    case "screenOrientation":
+                        hashMap.put("screenOrientation", Integer.valueOf(integer != null ? integer.intValue() : 0));
+                        break;
+                    case "enableLogging":
+                        if (bool != null && !bool.booleanValue()) {
+                            z2 = false;
+                        }
+                        hashMap.put("enableLogging", Boolean.valueOf(z2));
+                        break;
+                    case "notificationIcon":
+                        hashMap.put("notificationIcon", Integer.valueOf(this.mActivity.getResources().getIdentifier(toString(value), "drawable", this.mActivity.getPackageName())));
+                        break;
+                }
+            }
+        }
+        if (map != null && !map.containsKey("enableLogging")) {
+            hashMap.put("enableLogging", Boolean.valueOf(this.mIsDebug));
+        }
+        if (z) {
+            hashMap.put("manualLifecycleTracking", Boolean.TRUE);
+        }
+        return hashMap;
+    }
+
+    private Map<String, Object> convertOptions(Map<String, Object> map) {
+        HashMap hashMap = (HashMap) this.mConfig.clone();
+        boolean z = false;
+        if (map != null) {
+            for (Map.Entry<String, Object> entry : map.entrySet()) {
+                Boolean bool = toBoolean(entry.getValue());
+                String key = entry.getKey();
+                key.hashCode();
+                if (key.equals("fullPrivacy") || key.equals("enableFullPrivacy")) {
+                    hashMap.put("fullPrivacy", Boolean.valueOf(bool != null && bool.booleanValue()));
+                } else {
+                    log("Option is not supported:", entry.getKey());
+                }
+            }
+        }
+        try {
+            String lowerCase = StringStore.get(StringStore.Key.LOCATION_ISO_CODE).toLowerCase();
+            if (lowerCase != null) {
+                int i = 0;
+                while (true) {
+                    if (i >= this.countriesThatRequireFullPrivacy.size()) {
+                        break;
+                    }
+                    if (((String) this.countriesThatRequireFullPrivacy.get(i)).compareToIgnoreCase(lowerCase) == 0) {
+                        z = true;
+                        break;
+                    }
+                    i++;
+                }
+            }
+        } catch (Exception unused) {
+        }
+        if (this.mUnderAge || z) {
+            hashMap.put("fullPrivacy", Boolean.TRUE);
+        }
+        return hashMap;
+    }
+}

decompiled/sources/csdk/glucustomersupport/impl/GluImplBase.java

@@ -0,0 +1,192 @@
+package csdk.glucustomersupport.impl;
+
+import android.app.Activity;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.InstallSourceInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.Pair;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.unity3d.ads.core.data.datasource.AndroidStaticDeviceInfoDataSource;
+import csdk.glucustomersupport.BuildConfig;
+import csdk.glucustomersupport.IGluCustomerSupport;
+import csdk.glucustomersupport.IGluCustomerSupportListener;
+import csdk.glucustomersupport.eventbus.GluEventHandler;
+import csdk.glucustomersupport.util.ConfigUtil;
+import csdk.glucustomersupport.util.GluUtil;
+import csdk.glucustomersupport.util.StringStore;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes4.dex */
+public abstract class GluImplBase implements IGluCustomerSupport {
+    private List<Object> ltvTiers;
+    protected Activity mActivity;
+    protected GluEventHandler mEventHandler;
+    protected boolean mIsDebug;
+    protected IGluCustomerSupportListener mListener;
+    private String mLogName;
+    protected String mUserEmail;
+    protected String mUserID;
+    protected String mUserName;
+    protected int tier = 0;
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setListener(IGluCustomerSupportListener iGluCustomerSupportListener) {
+        this.mListener = iGluCustomerSupportListener;
+    }
+
+    public GluImplBase(Callable<Activity> callable, Map<String, Object> map, String str) {
+        this.mActivity = (Activity) GluUtil.call(callable);
+        this.mIsDebug = ConfigUtil.getBoolean(map, "csdk.gluCustomerSupport.debug.all", false);
+        this.mLogName = str;
+        this.ltvTiers = ConfigUtil.getList(map, "csdk.gluCustomerSupport.ltvTiers", Arrays.asList(Double.valueOf(0.01d), Double.valueOf(50.0d), Double.valueOf(100.0d), Double.valueOf(500.0d), Double.valueOf(2000.0d), Double.valueOf(10000.0d), Double.valueOf(25000.0d), Double.valueOf(50000.0d)));
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void init(GluEventHandler gluEventHandler) {
+        this.mEventHandler = gluEventHandler;
+        if (gluEventHandler != null) {
+            gluEventHandler.onInit(BuildConfig.VERSION_NAME);
+        }
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void destroy() {
+        log(InneractiveMediationDefs.GENDER_MALE, "destroy");
+        GluEventHandler gluEventHandler = this.mEventHandler;
+        if (gluEventHandler != null) {
+            gluEventHandler.onDestroy();
+        }
+        StringStore.destroy();
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void close() {
+        log(InneractiveMediationDefs.GENDER_MALE, "close");
+    }
+
+    public void log(Object... objArr) {
+        GluUtil.log(this.mIsDebug, this.mLogName, objArr);
+    }
+
+    public Pair<Map<String, Object>, Set<String>> getMetadata(Map<String, Object> map, List<Object> list) {
+        if (list == null) {
+            list = map == null ? null : toList(map.get("hs-tags"));
+        }
+        return Pair.create(updateMetadata(map), updateTags(list, map != null ? toDouble(map.get("ltv")) : null));
+    }
+
+    private Map<String, Object> updateMetadata(Map<String, Object> map) {
+        if (map == null) {
+            map = new HashMap<>();
+        }
+        map.put("analytics_id", StringStore.get(StringStore.Key.ANALYTICS_ID));
+        map.put("player_id", this.mUserID);
+        map.put("user_name", this.mUserName);
+        map.put("country_code", StringStore.get(StringStore.Key.LOCATION_ISO_CODE));
+        map.put("identity_pin", StringStore.get(StringStore.Key.IDENTITY_PIN));
+        map.put("under_age_user", StringStore.get(StringStore.Key.UNDER_AGE_USER));
+        map.put("preexisting_under_age_user", StringStore.get(StringStore.Key.PREEXISTING_UNDER_AGE_USER));
+        map.remove("hs-tags");
+        if (!map.containsKey("ltv")) {
+            log(InneractiveMediationDefs.GENDER_MALE, "ltv is missing");
+        }
+        return map;
+    }
+
+    private Set<String> updateTags(List<Object> list, Double d) {
+        HashSet hashSet = new HashSet();
+        if (list != null) {
+            Iterator<Object> it = list.iterator();
+            while (it.hasNext()) {
+                String gluImplBase = toString(it.next());
+                if (gluImplBase != null) {
+                    hashSet.add(gluImplBase.toLowerCase());
+                }
+            }
+        }
+        if (!hashSet.contains(AndroidStaticDeviceInfoDataSource.STORE_GOOGLE) && !hashSet.contains("amazon")) {
+            hashSet.add(getStore());
+        }
+        if (d != null) {
+            int i = 0;
+            Double[] dArr = (Double[]) this.ltvTiers.toArray(new Double[0]);
+            while (i < dArr.length && d.doubleValue() >= dArr[i].doubleValue()) {
+                i++;
+            }
+            hashSet.add("tier" + i);
+            this.tier = i;
+        }
+        return hashSet;
+    }
+
+    public Boolean toBoolean(Object obj) {
+        if (obj instanceof Boolean) {
+            return (Boolean) obj;
+        }
+        if ("true".equals(obj)) {
+            return Boolean.TRUE;
+        }
+        if ("false".equals(obj)) {
+            return Boolean.FALSE;
+        }
+        return null;
+    }
+
+    public String toString(Object obj) {
+        if (obj instanceof String) {
+            return (String) obj;
+        }
+        return null;
+    }
+
+    public Integer toInteger(Object obj) {
+        if (obj instanceof Integer) {
+            return (Integer) obj;
+        }
+        return null;
+    }
+
+    public Double toDouble(Object obj) {
+        if (obj instanceof Double) {
+            return (Double) obj;
+        }
+        if (obj instanceof Long) {
+            return new Double(((Long) obj).longValue());
+        }
+        return null;
+    }
+
+    public List<Object> toList(Object obj) {
+        if (obj instanceof List) {
+            return (List) obj;
+        }
+        return null;
+    }
+
+    public String getStore() {
+        String installerPackageName;
+        InstallSourceInfo installSourceInfo;
+        PackageManager packageManager = this.mActivity.getPackageManager();
+        try {
+            ApplicationInfo applicationInfo = packageManager.getApplicationInfo(this.mActivity.getPackageName(), 0);
+            if (Build.VERSION.SDK_INT >= 30) {
+                installSourceInfo = packageManager.getInstallSourceInfo(applicationInfo.packageName);
+                installerPackageName = installSourceInfo.getInstallingPackageName();
+            } else {
+                installerPackageName = packageManager.getInstallerPackageName(applicationInfo.packageName);
+            }
+            return "com.amazon.venezia".equals(installerPackageName) ? "amazon" : AndroidStaticDeviceInfoDataSource.STORE_GOOGLE;
+        } catch (Exception e) {
+            log("Exception", e);
+            return AndroidStaticDeviceInfoDataSource.STORE_GOOGLE;
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/impl/GluImplWrapper.java

@@ -0,0 +1,139 @@
+package csdk.glucustomersupport.impl;
+
+import csdk.glucustomersupport.IGluCustomerSupport;
+import csdk.glucustomersupport.IGluCustomerSupportListener;
+import csdk.glucustomersupport.eventbus.GluEventHandler;
+import csdk.glucustomersupport.util.GluTaskQueue;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class GluImplWrapper implements IGluCustomerSupport {
+    private IGluCustomerSupport mImpl;
+    private GluTaskQueue mQueue;
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void init(GluEventHandler gluEventHandler) {
+    }
+
+    public GluImplWrapper() {
+        GluTaskQueue gluTaskQueue = new GluTaskQueue();
+        this.mQueue = gluTaskQueue;
+        gluTaskQueue.suspend();
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void login(final Map<String, Object> map) {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.1
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.login(map);
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void logout() {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.2
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.logout();
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void queryNotificationCount() {
+        this.mQueue.runOnUiThread(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.3
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.queryNotificationCount();
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void show(final String str, final Map<String, Object> map) {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.4
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.show(str, map);
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void close() {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.5
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.close();
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setMetadata(final Map<String, Object> map, final List<Object> list, final Map<String, Object> map2) {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.6
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.setMetadata(map, list, map2);
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setLanguageCode(final String str) {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.7
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.setLanguageCode(str);
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void destroy() {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.8
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.destroy();
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setListener(final IGluCustomerSupportListener iGluCustomerSupportListener) {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.9
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.setListener(iGluCustomerSupportListener);
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setPushToken(final String str) {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.10
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.setPushToken(str);
+            }
+        });
+    }
+
+    @Override // csdk.glucustomersupport.IGluCustomerSupport
+    public void setConsentFlags(final Map<String, ?> map) {
+        this.mQueue.run(new Runnable() { // from class: csdk.glucustomersupport.impl.GluImplWrapper.11
+            @Override // java.lang.Runnable
+            public void run() {
+                GluImplWrapper.this.mImpl.setConsentFlags(map);
+            }
+        });
+    }
+
+    public void setImpl(IGluCustomerSupport iGluCustomerSupport) {
+        this.mImpl = iGluCustomerSupport;
+        this.mQueue.resume();
+    }
+}

decompiled/sources/csdk/glucustomersupport/impl/IAction2.java

@@ -0,0 +1,6 @@
+package csdk.glucustomersupport.impl;
+
+/* loaded from: classes4.dex */
+public interface IAction2<T1, T2> {
+    void apply(T1 t1, T2 t2);
+}

decompiled/sources/csdk/glucustomersupport/push/GluCSFirebaseMessagingService.java

@@ -0,0 +1,43 @@
+package csdk.glucustomersupport.push;
+
+import android.content.Context;
+import android.util.Log;
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+import com.helpshift.Helpshift;
+import csdk.glucustomersupport.impl.GluHelpshift;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class GluCSFirebaseMessagingService extends FirebaseMessagingService {
+    @Override // com.google.firebase.messaging.FirebaseMessagingService
+    public void onNewToken(String str) {
+    }
+
+    @Override // android.app.Service
+    public void onCreate() {
+        super.onCreate();
+        GluHelpshift.internal_Install(getApplication());
+    }
+
+    @Override // com.google.firebase.messaging.FirebaseMessagingService
+    public void onMessageReceived(RemoteMessage remoteMessage) {
+        super.onMessageReceived(remoteMessage);
+        if (remoteMessage != null) {
+            Map data = remoteMessage.getData();
+            String str = (String) data.get("origin");
+            if (str != null && str.equals("helpshift")) {
+                Helpshift.handlePush(data);
+            }
+            try {
+                Class.forName("csdk.glumarketing.GluMKTFirebaseMessagingService").getMethod("handleMessage", Context.class, RemoteMessage.class).invoke(null, this, remoteMessage);
+            } catch (ClassNotFoundException unused) {
+                Log.e("CS", "GluMKTFirebaseMessagingService not found");
+            } catch (NoSuchMethodException unused2) {
+                Log.e("CS", "handleMessage not found");
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/unity/UnityCustomerSupportFactory.java

@@ -0,0 +1,70 @@
+package csdk.glucustomersupport.unity;
+
+import android.app.Activity;
+import android.text.TextUtils;
+import com.unity3d.player.UnityPlayer;
+import csdk.glucustomersupport.GluCustomerSupportSessionEndedEvent;
+import csdk.glucustomersupport.GluCustomerSupportSessionStartedEvent;
+import csdk.glucustomersupport.GluFactory;
+import csdk.glucustomersupport.IGluCustomerSupport;
+import csdk.glucustomersupport.IGluCustomerSupportListener;
+import csdk.glucustomersupport.NotificationCountEvent;
+import csdk.glucustomersupport.util.GluUtil;
+import csdk.glucustomersupport.util.JsonUtil;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class UnityCustomerSupportFactory {
+
+    public static class UnityCustomerSupportListener implements IGluCustomerSupportListener {
+        private final String gameObject;
+
+        public UnityCustomerSupportListener(String str) {
+            this.gameObject = str;
+        }
+
+        @Override // csdk.glucustomersupport.IGluCustomerSupportListener
+        public void onQueryNotificationCount(NotificationCountEvent notificationCountEvent) {
+            UnityPlayer.UnitySendMessage(this.gameObject, "AndroidCustomerSupportOnQueryNotificationCount", JsonUtil.toJson(notificationCountEvent));
+        }
+
+        @Override // csdk.glucustomersupport.IGluCustomerSupportListener
+        public void onHelpshiftSessionStarted(GluCustomerSupportSessionStartedEvent gluCustomerSupportSessionStartedEvent) {
+            UnityPlayer.UnitySendMessage(this.gameObject, "AndroidCustomerSupportOnHelpshiftSessionStarted", JsonUtil.toJson(gluCustomerSupportSessionStartedEvent));
+        }
+
+        @Override // csdk.glucustomersupport.IGluCustomerSupportListener
+        public void onHelpshiftSessionEnded(GluCustomerSupportSessionEndedEvent gluCustomerSupportSessionEndedEvent) {
+            UnityPlayer.UnitySendMessage(this.gameObject, "AndroidCustomerSupportOnHelpshiftSessionEnded", JsonUtil.toJson(gluCustomerSupportSessionEndedEvent));
+        }
+    }
+
+    public IGluCustomerSupport createCustomerSupport(String str, String str2, String str3) {
+        Map<String, Object> parseJsonObject;
+        Callable<Activity> callable = new Callable<Activity>() { // from class: csdk.glucustomersupport.unity.UnityCustomerSupportFactory.1
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // java.util.concurrent.Callable
+            public Activity call() throws Exception {
+                Activity activity = UnityPlayer.currentActivity;
+                if (activity != null) {
+                    return activity;
+                }
+                throw new Error("Current activity is null.");
+            }
+        };
+        if (TextUtils.isEmpty(str3)) {
+            parseJsonObject = null;
+        } else {
+            try {
+                parseJsonObject = JsonUtil.parseJsonObject(str3);
+            } catch (JSONException e) {
+                throw GluUtil.propagate(e);
+            }
+        }
+        IGluCustomerSupport createCustomerSupport = new GluFactory().createCustomerSupport(callable, GluUtil.emptyToNull(str2), parseJsonObject);
+        createCustomerSupport.setListener(new UnityCustomerSupportListener(str));
+        return createCustomerSupport;
+    }
+}

decompiled/sources/csdk/glucustomersupport/unity/UnityMarshallingUtil.java

@@ -0,0 +1,78 @@
+package csdk.glucustomersupport.unity;
+
+import com.facebook.internal.security.CertificateUtil;
+import csdk.glucustomersupport.Consts;
+import csdk.glucustomersupport.IGluCustomerSupport;
+import csdk.glucustomersupport.util.GluUtil;
+import csdk.glucustomersupport.util.JsonUtil;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class UnityMarshallingUtil {
+    public static void clearUserActions(IGluCustomerSupport iGluCustomerSupport) {
+    }
+
+    public static void logUserAction(IGluCustomerSupport iGluCustomerSupport, String str) {
+    }
+
+    public static void login(IGluCustomerSupport iGluCustomerSupport, String str) {
+        iGluCustomerSupport.login(JsonUtil.toMap(str));
+    }
+
+    public static void logout(IGluCustomerSupport iGluCustomerSupport) {
+        iGluCustomerSupport.logout();
+    }
+
+    public static void queryNotificationCount(IGluCustomerSupport iGluCustomerSupport) {
+        iGluCustomerSupport.queryNotificationCount();
+    }
+
+    public static void showDefault(IGluCustomerSupport iGluCustomerSupport, String str) {
+        iGluCustomerSupport.show(Consts.SHOW_TYPE_DEFAULT, JsonUtil.toMap(str));
+    }
+
+    public static void showFAQs(IGluCustomerSupport iGluCustomerSupport, String str) {
+        iGluCustomerSupport.show(Consts.SHOW_TYPE_FAQ, JsonUtil.toMap(str));
+    }
+
+    public static void showSingleFAQ(IGluCustomerSupport iGluCustomerSupport, String str, String str2) {
+        Map<String, Object> map = JsonUtil.toMap(str2);
+        map.put(Consts.SHOW_OPTION_FAQ_ID, str);
+        iGluCustomerSupport.show(Consts.SHOW_TYPE_FAQ, map);
+    }
+
+    public static void showFAQSection(IGluCustomerSupport iGluCustomerSupport, String str, String str2) {
+        Map<String, Object> map = JsonUtil.toMap(str2);
+        map.put(Consts.SHOW_OPTION_FAQ_SECTION, str);
+        iGluCustomerSupport.show(Consts.SHOW_TYPE_FAQ, map);
+    }
+
+    public static void showConversation(IGluCustomerSupport iGluCustomerSupport, String str) {
+        iGluCustomerSupport.show(Consts.SHOW_TYPE_CHAT, JsonUtil.toMap(str));
+    }
+
+    public static void close(IGluCustomerSupport iGluCustomerSupport) {
+        iGluCustomerSupport.close();
+    }
+
+    public static void setMetadata(IGluCustomerSupport iGluCustomerSupport, String str, String str2, String str3) {
+        Map<String, Object> map = JsonUtil.toMap(str3);
+        Map<String, Object> createMap = GluUtil.createMap();
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            Map createMap2 = GluUtil.createMap();
+            String[] split = ((String) entry.getValue()).split(CertificateUtil.DELIMITER, 2);
+            if (2 == split.length) {
+                String str4 = split[0];
+                String str5 = split[1];
+                createMap2.put("type", str4);
+                createMap2.put("value", str5);
+                createMap.put(entry.getKey(), createMap2);
+            }
+        }
+        iGluCustomerSupport.setMetadata(JsonUtil.toMap(str), JsonUtil.toList(str2), createMap);
+    }
+
+    public static void setLanguageCode(IGluCustomerSupport iGluCustomerSupport, String str) {
+        iGluCustomerSupport.setLanguageCode(str);
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/ConfigUtil.java

@@ -0,0 +1,148 @@
+package csdk.glucustomersupport.util;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.Consts;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class ConfigUtil {
+    public static boolean getBoolean(@Nullable Object obj, @NonNull String str) {
+        return getBoolean(obj, str, false);
+    }
+
+    public static boolean getBoolean(@Nullable Object obj, @NonNull String str, boolean z) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return z;
+        }
+        if (object instanceof Boolean) {
+            return ((Boolean) object).booleanValue();
+        }
+        if (object instanceof String) {
+            String str2 = (String) object;
+            if (TextUtils.equals(str2, "true")) {
+                return true;
+            }
+            if (TextUtils.equals(str2, "false")) {
+                return false;
+            }
+            throw new IllegalArgumentException("Can't convert string to boolean value: " + str2 + Consts.STRING_PERIOD);
+        }
+        throw new IllegalArgumentException("Unsupported type for boolean value: " + object.getClass());
+    }
+
+    public static long getLong(@Nullable Object obj, @NonNull String str) {
+        return getLong(obj, str, 0L);
+    }
+
+    public static long getLong(@Nullable Object obj, @NonNull String str, long j) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return j;
+        }
+        if (object instanceof Number) {
+            return ((Number) object).longValue();
+        }
+        if (object instanceof String) {
+            return Long.parseLong((String) object);
+        }
+        throw new IllegalArgumentException("Unsupported type for long value: " + object.getClass());
+    }
+
+    public static double getDouble(@Nullable Object obj, @NonNull String str) {
+        return getDouble(obj, str, 0.0d);
+    }
+
+    public static double getDouble(@Nullable Object obj, @NonNull String str, double d) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return d;
+        }
+        if (object instanceof Number) {
+            return ((Number) object).doubleValue();
+        }
+        if (object instanceof String) {
+            return Double.parseDouble((String) object);
+        }
+        throw new IllegalArgumentException("Unsupported type for double value: " + object.getClass());
+    }
+
+    @Nullable
+    public static String getString(@Nullable Object obj, @NonNull String str) {
+        return getString(obj, str, null);
+    }
+
+    @Nullable
+    public static String getString(@Nullable Object obj, @NonNull String str, @Nullable String str2) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return str2;
+        }
+        if (object instanceof String) {
+            return (String) object;
+        }
+        if ((object instanceof Number) || (object instanceof Boolean)) {
+            return object.toString();
+        }
+        throw new IllegalArgumentException("Unsupported type for string value: " + object.getClass());
+    }
+
+    @Nullable
+    public static Map<String, Object> getMap(@Nullable Object obj, @NonNull String str) {
+        return getMap(obj, str, null);
+    }
+
+    @Nullable
+    public static Map<String, Object> getMap(@Nullable Object obj, @NonNull String str, @Nullable Map<String, Object> map) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return map;
+        }
+        if (object instanceof Map) {
+            return (Map) object;
+        }
+        throw new IllegalArgumentException("Unsupported type for map value: " + object.getClass());
+    }
+
+    public static List<Object> getList(@Nullable Object obj, @NonNull String str) {
+        return getList(obj, str, null);
+    }
+
+    @Nullable
+    public static List<Object> getList(@Nullable Object obj, @NonNull String str, @Nullable List<Object> list) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return list;
+        }
+        if (object instanceof List) {
+            return (List) object;
+        }
+        throw new IllegalArgumentException("Unsupported type for list value: " + object.getClass());
+    }
+
+    public static Object getObject(@Nullable Object obj, @NonNull String str) {
+        return getObject(obj, str, null);
+    }
+
+    @Nullable
+    public static Object getObject(@Nullable Object obj, @NonNull String str, @Nullable Object obj2) {
+        if (obj == null) {
+            return obj2;
+        }
+        for (String str2 : splitPath(str)) {
+            if (obj == null) {
+                return obj2;
+            }
+            obj = ((Map) obj).get(str2);
+        }
+        return obj;
+    }
+
+    @NonNull
+    private static String[] splitPath(@NonNull String str) {
+        return str.split("\\.");
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/GluTaskQueue.java

@@ -0,0 +1,66 @@
+package csdk.glucustomersupport.util;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes4.dex */
+public class GluTaskQueue {
+    private Queue<QueueObject> mQueue = new LinkedList();
+    private AtomicBoolean mIsRunning = new AtomicBoolean();
+
+    public class QueueObject {
+        public boolean runOnUiThread;
+        public Runnable runnable;
+
+        private QueueObject() {
+        }
+    }
+
+    public void suspend() {
+        this.mIsRunning.set(false);
+    }
+
+    public void resume() {
+        this.mIsRunning.set(true);
+    }
+
+    public void run(Runnable runnable) {
+        run(runnable, false);
+    }
+
+    public void runOnUiThread(Runnable runnable) {
+        run(runnable, true);
+    }
+
+    private void run(Runnable runnable, boolean z) {
+        QueueObject queueObject = new QueueObject();
+        queueObject.runnable = runnable;
+        queueObject.runOnUiThread = z;
+        synchronized (this) {
+            this.mQueue.add(queueObject);
+        }
+        run();
+    }
+
+    private void run() {
+        QueueObject poll;
+        while (this.mIsRunning.get()) {
+            synchronized (this) {
+                try {
+                    poll = !this.mQueue.isEmpty() ? this.mQueue.poll() : null;
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+            if (poll == null) {
+                return;
+            }
+            if (poll.runOnUiThread) {
+                GluUtil.runOnUIThread(poll.runnable);
+            } else {
+                poll.runnable.run();
+            }
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/GluUtil.java

@@ -0,0 +1,88 @@
+package csdk.glucustomersupport.util;
+
+import android.os.Handler;
+import android.os.Looper;
+import csdk.glucustomersupport.util.log.YLogger;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes4.dex */
+public class GluUtil {
+    private static Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public static void require(boolean z) {
+        if (!z) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void require(boolean z, String str) {
+        if (z) {
+            return;
+        }
+        if (str != null) {
+            throw new IllegalArgumentException(str);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public static RuntimeException propagate(Throwable th) {
+        if (th instanceof Error) {
+            throw ((Error) th);
+        }
+        if (th instanceof RuntimeException) {
+            throw ((RuntimeException) th);
+        }
+        throw new RuntimeException(th);
+    }
+
+    public static String emptyToNull(String str) {
+        if (str == null || str.length() > 0) {
+            return str;
+        }
+        return null;
+    }
+
+    public static <T> T call(Callable<T> callable) {
+        try {
+            return callable.call();
+        } catch (Exception e) {
+            throw propagate(e);
+        }
+    }
+
+    public static <K, V> Map<K, V> createMap() {
+        return new HashMap();
+    }
+
+    public static <K, V> Map<K, V> shallowClone(Map<K, V> map) {
+        if (map == null) {
+            return null;
+        }
+        Map<K, V> createMap = createMap();
+        createMap.putAll(map);
+        return createMap;
+    }
+
+    public static void runOnUIThread(Runnable runnable) {
+        require(runnable != null, "runnable == null");
+        if (!mainHandler.post(runnable)) {
+            throw new IllegalStateException("Failed to post runnable");
+        }
+    }
+
+    public static void runOnUIThreadDelayed(Runnable runnable, long j) {
+        require(runnable != null, "runnable == null");
+        if (!mainHandler.postDelayed(runnable, j)) {
+            throw new IllegalStateException("Failed to post runnable");
+        }
+    }
+
+    public static void log(boolean z, String str, Object... objArr) {
+        if (z) {
+            YLogger.format(str, objArr);
+            YLogger.findThrowable(objArr);
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/IAction2.java

@@ -0,0 +1,6 @@
+package csdk.glucustomersupport.util;
+
+/* loaded from: classes4.dex */
+public interface IAction2<T1, T2> {
+    void apply(T1 t1, T2 t2);
+}

decompiled/sources/csdk/glucustomersupport/util/ISerializableJsonObject.java

@@ -0,0 +1,9 @@
+package csdk.glucustomersupport.util;
+
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public interface ISerializableJsonObject {
+    void write(JSONStringer jSONStringer) throws JSONException;
+}

decompiled/sources/csdk/glucustomersupport/util/JsonUtil.java

@@ -0,0 +1,349 @@
+package csdk.glucustomersupport.util;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.JsonReader;
+import android.util.JsonToken;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import csdk.gluads.Consts;
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class JsonUtil {
+    public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+        return Api11.parseJsonObject(str);
+    }
+
+    public static List<Object> parseJsonList(String str) throws JSONException {
+        return Api11.parseJsonArray(str);
+    }
+
+    public static Map<String, Object> toMap(Bundle bundle) {
+        return (Map) toSimpleJavaTypes(bundle);
+    }
+
+    public static Map<String, Object> toMap(JSONObject jSONObject) {
+        return (Map) toSimpleJavaTypes(jSONObject);
+    }
+
+    public static Map<String, Object> toMap(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            return parseJsonObject(str);
+        } catch (JSONException e) {
+            throw GluUtil.propagate(e);
+        }
+    }
+
+    public static List<Object> toList(JSONObject jSONObject) {
+        return (List) toSimpleJavaTypes(jSONObject);
+    }
+
+    public static List<Object> toList(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            return parseJsonList(str);
+        } catch (JSONException e) {
+            throw GluUtil.propagate(e);
+        }
+    }
+
+    public static String toJson(Object obj) {
+        JSONStringer jSONStringer = new JSONStringer();
+        try {
+            value(jSONStringer, obj);
+            return jSONStringer.toString();
+        } catch (JSONException e) {
+            throw GluUtil.propagate(e);
+        }
+    }
+
+    public static void optKeyValue(JSONStringer jSONStringer, String str, Object obj) throws JSONException {
+        if (obj != null) {
+            jSONStringer.key(str);
+            value(jSONStringer, obj);
+        }
+    }
+
+    public static void value(JSONStringer jSONStringer, Object obj) throws JSONException {
+        if (obj == null) {
+            jSONStringer.value(obj);
+            return;
+        }
+        if (obj instanceof ISerializableJsonObject) {
+            jSONStringer.object();
+            ((ISerializableJsonObject) obj).write(jSONStringer);
+            jSONStringer.endObject();
+            return;
+        }
+        if ((obj instanceof Number) || (obj instanceof Boolean) || (obj instanceof CharSequence) || (obj instanceof Character)) {
+            jSONStringer.value(obj);
+            return;
+        }
+        if (obj instanceof Map) {
+            serializeMap(jSONStringer, (Map) obj);
+            return;
+        }
+        if (obj instanceof Iterable) {
+            serializeIterable(jSONStringer, (Iterable) obj);
+            return;
+        }
+        if (obj.getClass().isArray()) {
+            serializeArray(jSONStringer, obj);
+        } else if (obj instanceof Throwable) {
+            serializeThrowable(jSONStringer, (Throwable) obj);
+        } else {
+            serializeDefaultObject(jSONStringer, obj);
+        }
+    }
+
+    private static void serializeMap(JSONStringer jSONStringer, Map<?, ?> map) throws JSONException {
+        Iterator<?> it = map.keySet().iterator();
+        while (it.hasNext()) {
+            if (!(it.next() instanceof CharSequence)) {
+                serializeMapWithNonStringKeys(jSONStringer, map);
+                return;
+            }
+        }
+        jSONStringer.object();
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            jSONStringer.key(entry.getKey().toString());
+            value(jSONStringer, entry.getValue());
+        }
+        jSONStringer.endObject();
+    }
+
+    private static void serializeMapWithNonStringKeys(JSONStringer jSONStringer, Map<?, ?> map) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "cls", "flatmap");
+        jSONStringer.key(Consts.KEY_TAPJOY_USER_ID_VERSION).array();
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            jSONStringer.array();
+            value(jSONStringer, entry.getKey());
+            value(jSONStringer, entry.getValue());
+            jSONStringer.endArray();
+        }
+        jSONStringer.endArray();
+        jSONStringer.endObject();
+    }
+
+    private static void serializeIterable(JSONStringer jSONStringer, Iterable<?> iterable) throws JSONException {
+        jSONStringer.array();
+        Iterator<?> it = iterable.iterator();
+        while (it.hasNext()) {
+            value(jSONStringer, it.next());
+        }
+        jSONStringer.endArray();
+    }
+
+    private static void serializeArray(JSONStringer jSONStringer, Object obj) throws JSONException {
+        int length = Array.getLength(obj);
+        jSONStringer.array();
+        for (int i = 0; i < length; i++) {
+            value(jSONStringer, Array.get(obj, i));
+        }
+        jSONStringer.endArray();
+    }
+
+    private static void serializeThrowable(JSONStringer jSONStringer, Throwable th) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "cls", th.getClass().getSimpleName());
+        optKeyValue(jSONStringer, InneractiveMediationDefs.GENDER_MALE, th.getMessage());
+        jSONStringer.endObject();
+    }
+
+    private static void serializeDefaultObject(JSONStringer jSONStringer, Object obj) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "str", obj.toString());
+        jSONStringer.endObject();
+    }
+
+    private static Object toSimpleJavaTypes(Object obj) {
+        if (obj == null || (obj instanceof String) || (obj instanceof Number) || (obj instanceof Boolean)) {
+            return obj;
+        }
+        if ((obj instanceof CharSequence) || (obj instanceof Character)) {
+            return obj.toString();
+        }
+        if (obj instanceof Iterable) {
+            ArrayList arrayList = new ArrayList();
+            Iterator it = ((Iterable) obj).iterator();
+            while (it.hasNext()) {
+                arrayList.add(toSimpleJavaTypes(it.next()));
+            }
+            return arrayList;
+        }
+        int i = 0;
+        if (obj.getClass().isArray()) {
+            ArrayList arrayList2 = new ArrayList();
+            int length = Array.getLength(obj);
+            while (i < length) {
+                arrayList2.add(toSimpleJavaTypes(Array.get(obj, i)));
+                i++;
+            }
+            return arrayList2;
+        }
+        if (obj instanceof Bundle) {
+            Map createMap = GluUtil.createMap();
+            Bundle bundle = (Bundle) obj;
+            for (String str : bundle.keySet()) {
+                createMap.put(str, toSimpleJavaTypes(bundle.get(str)));
+            }
+            return createMap;
+        }
+        if (obj instanceof JSONArray) {
+            ArrayList arrayList3 = new ArrayList();
+            JSONArray jSONArray = (JSONArray) obj;
+            while (i < jSONArray.length()) {
+                arrayList3.add(toSimpleJavaTypes(jSONArray.opt(i)));
+                i++;
+            }
+            return arrayList3;
+        }
+        if (obj instanceof JSONObject) {
+            Map createMap2 = GluUtil.createMap();
+            JSONObject jSONObject = (JSONObject) obj;
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                createMap2.put(next, toSimpleJavaTypes(jSONObject.opt(next)));
+            }
+            return createMap2;
+        }
+        if (obj == JSONObject.NULL) {
+            return null;
+        }
+        throw new IllegalArgumentException(String.format("Unsupported type %s", obj.getClass()));
+    }
+
+    @TargetApi(11)
+    public static class Api11 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            JsonReader jsonReader;
+            JsonReader jsonReader2 = null;
+            try {
+                try {
+                    jsonReader = new JsonReader(new StringReader(str));
+                } catch (Throwable th) {
+                    th = th;
+                }
+            } catch (IOException e) {
+                e = e;
+            }
+            try {
+                jsonReader.setLenient(true);
+                Map<String, Object> parseJsonObject = parseJsonObject(jsonReader);
+                try {
+                    jsonReader.close();
+                    return parseJsonObject;
+                } catch (IOException e2) {
+                    throw GluUtil.propagate(e2);
+                }
+            } catch (IOException e3) {
+                e = e3;
+                throw GluUtil.propagate(e);
+            } catch (Throwable th2) {
+                th = th2;
+                jsonReader2 = jsonReader;
+                if (jsonReader2 != null) {
+                    try {
+                        jsonReader2.close();
+                    } catch (IOException e4) {
+                        throw GluUtil.propagate(e4);
+                    }
+                }
+                throw th;
+            }
+        }
+
+        public static List<Object> parseJsonArray(String str) throws JSONException {
+            try {
+                JsonReader jsonReader = new JsonReader(new StringReader(str));
+                jsonReader.setLenient(true);
+                return parseJsonArray(jsonReader);
+            } catch (IOException e) {
+                throw GluUtil.propagate(e);
+            }
+        }
+
+        public static Object parseJsonValue(JsonReader jsonReader) throws JSONException, IOException {
+            JsonToken peek = jsonReader.peek();
+            if (peek == JsonToken.BEGIN_OBJECT) {
+                return parseJsonObject(jsonReader);
+            }
+            if (peek == JsonToken.BEGIN_ARRAY) {
+                return parseJsonArray(jsonReader);
+            }
+            if (peek == JsonToken.BOOLEAN) {
+                return Boolean.valueOf(jsonReader.nextBoolean());
+            }
+            if (peek == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return null;
+            }
+            if (peek == JsonToken.NUMBER) {
+                String nextString = jsonReader.nextString();
+                if (nextString.contains(Consts.STRING_PERIOD) || nextString.contains("e") || nextString.contains("E")) {
+                    return Double.valueOf(Double.parseDouble(nextString));
+                }
+                return Long.valueOf(Long.parseLong(nextString));
+            }
+            if (peek == JsonToken.STRING) {
+                return jsonReader.nextString();
+            }
+            throw new JSONException("Unexpected token " + peek);
+        }
+
+        public static Map<String, Object> parseJsonObject(JsonReader jsonReader) throws JSONException, IOException {
+            Map<String, Object> createMap = GluUtil.createMap();
+            jsonReader.beginObject();
+            while (true) {
+                JsonToken peek = jsonReader.peek();
+                if (peek == JsonToken.END_OBJECT) {
+                    jsonReader.endObject();
+                    return createMap;
+                }
+                if (peek == JsonToken.NAME) {
+                    createMap.put(jsonReader.nextName(), parseJsonValue(jsonReader));
+                } else {
+                    throw new JSONException("Expected } or name but found " + peek);
+                }
+            }
+        }
+
+        public static List<Object> parseJsonArray(JsonReader jsonReader) throws JSONException, IOException {
+            ArrayList arrayList = new ArrayList();
+            jsonReader.beginArray();
+            while (jsonReader.peek() != JsonToken.END_ARRAY) {
+                arrayList.add(parseJsonValue(jsonReader));
+            }
+            jsonReader.endArray();
+            return arrayList;
+        }
+    }
+
+    public static class Api1 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            return JsonUtil.toMap(new JSONObject(str));
+        }
+
+        public static List<Object> parseJsonArray(String str) throws JSONException {
+            return JsonUtil.toList(new JSONObject(str));
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/JsonWebToken.java

@@ -0,0 +1,22 @@
+package csdk.glucustomersupport.util;
+
+import android.text.TextUtils;
+import com.google.android.gms.fido.u2f.api.common.ClientData;
+import io.jsonwebtoken.JwtBuilder;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import java.util.Date;
+
+/* loaded from: classes4.dex */
+public class JsonWebToken {
+    public static String Create(String str, String str2, String str3) throws Exception {
+        JwtBuilder issuedAt = Jwts.builder().setHeaderParam("alg", "HS256").setHeaderParam(ClientData.KEY_TYPE, "JWT").setIssuedAt(new Date());
+        if (!TextUtils.isEmpty(str)) {
+            issuedAt.claim("externalId", str);
+        }
+        if (!TextUtils.isEmpty(str2)) {
+            issuedAt.claim("email", str2);
+        }
+        return issuedAt.signWith(SignatureAlgorithm.HS256, str3.getBytes()).compact();
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/StringStore.java

@@ -0,0 +1,84 @@
+package csdk.glucustomersupport.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class StringStore {
+    private static final String gcsClassName = "csdk.glucentralservices.kvstore.StringStore";
+    private static final String getMethodName = "get";
+    private static final Map<Key, String> keys = new HashMap<Key, String>() { // from class: csdk.glucustomersupport.util.StringStore.1
+        {
+            put(Key.ANALYTICS_ID, "AnalyticsID");
+            put(Key.LOCATION_ISO_CODE, "LocationISOCode");
+            put(Key.IDENTITY_PIN, "IdentityPin");
+            put(Key.UNDER_AGE_USER, "UnderAge");
+            put(Key.PREEXISTING_UNDER_AGE_USER, "PreExistingUnderAge");
+        }
+    };
+    private static final String setMethodName = "set";
+
+    public enum Key {
+        ANALYTICS_ID,
+        LOCATION_ISO_CODE,
+        IDENTITY_PIN,
+        UNDER_AGE_USER,
+        PREEXISTING_UNDER_AGE_USER
+    }
+
+    private static void log(String str) {
+    }
+
+    public static void init() {
+        set("*init", "glucustomersupport");
+    }
+
+    public static void destroy() {
+        set("*destroy", "glucustomersupport");
+    }
+
+    private static String get(String str) {
+        try {
+            return (String) csdk.glucentralservices.kvstore.StringStore.class.getMethod(getMethodName, String.class).invoke(null, str);
+        } catch (ClassNotFoundException | NoSuchMethodException unused) {
+            log("Can't find GCS");
+            return null;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private static void set(String str, String str2) {
+        try {
+            csdk.glucentralservices.kvstore.StringStore.class.getMethod(setMethodName, String.class, String.class).invoke(null, str, str2);
+        } catch (ClassNotFoundException | NoSuchMethodException unused) {
+            log("Can't find GCS");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static String get(Key key) {
+        Map<Key, String> map = keys;
+        if (!map.containsKey(key)) {
+            log("Invalid Key: " + key);
+            return null;
+        }
+        return get(map.get(key));
+    }
+
+    public static String getOrDefault(Key key, String str) {
+        String str2 = get(key);
+        return (str2 == null || str2.isEmpty()) ? str : str2;
+    }
+
+    public static void set(Key key, String str) {
+        Map<Key, String> map = keys;
+        if (!map.containsKey(key)) {
+            log("Invalid Key: " + key);
+            return;
+        }
+        set(map.get(key), str);
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/log/YLogger.java

@@ -0,0 +1,132 @@
+package csdk.glucustomersupport.util.log;
+
+import android.text.TextUtils;
+import csdk.glucustomersupport.util.GluUtil;
+import csdk.glucustomersupport.util.JsonUtil;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes4.dex */
+public class YLogger {
+    private final Logger log;
+
+    public YLogger(Logger logger) {
+        this.log = logger;
+    }
+
+    public void t(String str, Object... objArr) {
+        if (isTraceEnabled()) {
+            this.log.log(Level.FINEST, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public void d(String str, Object... objArr) {
+        if (isDebugEnabled()) {
+            this.log.log(Level.FINE, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public void i(String str, Object... objArr) {
+        if (isInfoEnabled()) {
+            this.log.log(Level.INFO, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public void w(String str, Object... objArr) {
+        if (isWarnEnabled()) {
+            this.log.log(Level.WARNING, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public void e(String str, Object... objArr) {
+        if (isErrorEnabled()) {
+            this.log.log(Level.SEVERE, format(str, objArr), findThrowable(objArr));
+        }
+    }
+
+    public boolean isTraceEnabled() {
+        return this.log.isLoggable(Level.FINEST);
+    }
+
+    public boolean isDebugEnabled() {
+        return this.log.isLoggable(Level.FINE);
+    }
+
+    public boolean isInfoEnabled() {
+        return this.log.isLoggable(Level.INFO);
+    }
+
+    public boolean isWarnEnabled() {
+        return this.log.isLoggable(Level.WARNING);
+    }
+
+    public boolean isErrorEnabled() {
+        return this.log.isLoggable(Level.SEVERE);
+    }
+
+    public static String format(String str, Object... objArr) {
+        try {
+            JSONStringer object = new JSONStringer().array().value(str).object();
+            appendPlistToJson(object, objArr);
+            Object[] plistTail = plistTail(objArr);
+            if (plistTail != null) {
+                appendPlistToJson(object, plistTail);
+            }
+            object.endObject().endArray();
+            return "#evu" + object.toString();
+        } catch (JSONException e) {
+            throw GluUtil.propagate(e);
+        }
+    }
+
+    public static Throwable findThrowable(Object... objArr) {
+        Throwable findThrowableNoTail = findThrowableNoTail(objArr);
+        if (findThrowableNoTail != null) {
+            return findThrowableNoTail;
+        }
+        Object[] plistTail = plistTail(objArr);
+        if (plistTail != null) {
+            return findThrowableNoTail(plistTail);
+        }
+        return null;
+    }
+
+    private static Throwable findThrowableNoTail(Object... objArr) {
+        int length = objArr.length - (objArr.length % 2);
+        for (int i = 0; i < length; i += 2) {
+            if (TextUtils.equals((String) objArr[i], "e")) {
+                Object obj = objArr[i + 1];
+                if (obj instanceof Throwable) {
+                    return (Throwable) obj;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static Object[] plistTail(Object[] objArr) {
+        int length = objArr.length;
+        int i = length - (length % 2);
+        if (i < length) {
+            Object obj = objArr[i];
+            if (obj instanceof Object[]) {
+                return (Object[]) obj;
+            }
+        }
+        return null;
+    }
+
+    private static void appendPlistToJson(JSONStringer jSONStringer, Object[] objArr) throws JSONException {
+        int length = objArr.length;
+        int i = length - (length % 2);
+        for (int i2 = 0; i2 < i; i2 += 2) {
+            Object obj = objArr[i2];
+            Object obj2 = objArr[i2 + 1];
+            if (obj instanceof String) {
+                JsonUtil.optKeyValue(jSONStringer, (String) obj, obj2);
+            }
+        }
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/log/YLoggerFactory.java

@@ -0,0 +1,14 @@
+package csdk.glucustomersupport.util.log;
+
+import java.util.logging.Logger;
+
+/* loaded from: classes4.dex */
+public class YLoggerFactory {
+    public static YLogger getLogger(String str) {
+        return new YLogger(Logger.getLogger(str));
+    }
+
+    public static YLogger getLogger(Class<?> cls) {
+        return getLogger(cls.getName());
+    }
+}

decompiled/sources/csdk/glucustomersupport/util/log/YLoggers.java

@@ -0,0 +1,81 @@
+package csdk.glucustomersupport.util.log;
+
+import android.os.Build;
+import com.ironsource.nb;
+import csdk.gluads.Consts;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public class YLoggers {
+    private static final int CALLER_INDEX = 1;
+
+    public static void sdkVersion(YLogger yLogger, String str, String str2) {
+        yLogger.i("SDK.VERSION", nb.q, str, Consts.KEY_TAPJOY_USER_ID_VERSION, str2);
+    }
+
+    public static void sdkConfiguration(YLogger yLogger, String str, Object... objArr) {
+        yLogger.i("CONFIG.SDK." + str, objArr);
+    }
+
+    public static void componentConfiguration(YLogger yLogger, String str, Object... objArr) {
+        yLogger.i("CONFIG.COMPONENT." + str, objArr);
+    }
+
+    public static void sdkConfigurationError(YLogger yLogger, String str, Object... objArr) {
+        yLogger.i("CONFIG.SDK." + str, objArr);
+    }
+
+    public static void componentConfigurationError(YLogger yLogger, String str, Object... objArr) {
+        yLogger.e("CONFIG.COMPONENT." + str, objArr);
+    }
+
+    public static void ctor(YLogger yLogger, Object... objArr) {
+        yLogger.t("TRACE.METHOD.INVOKE", nb.q, "#ctor", "args", objArr);
+    }
+
+    public static void method(YLogger yLogger, Object... objArr) {
+        if (yLogger.isTraceEnabled()) {
+            StackTraceElement[] stackTrace = new Throwable().getStackTrace();
+            if (stackTrace.length > 1) {
+                yLogger.t("TRACE.METHOD.INVOKE", nb.q, stackTrace[1].getMethodName(), "args", objArr);
+            }
+        }
+    }
+
+    public static void warn(YLogger yLogger, Throwable th, String str, Object... objArr) {
+        yLogger.w(str + ".ERROR", concatArrays(objArr, new Object[]{"e", th}));
+    }
+
+    public static void error(YLogger yLogger, Throwable th, String str, Object... objArr) {
+        yLogger.e(str + ".ERROR", concatArrays(objArr, new Object[]{"e", th}));
+    }
+
+    public static void beginAsync(YLogger yLogger, String str, Object... objArr) {
+        yLogger.d("ASYNC.BEGIN", concatArrays(new Object[]{nb.q, str}, objArr));
+    }
+
+    public static void endAsync(YLogger yLogger, String str, Object... objArr) {
+        yLogger.d("ASYNC.END", concatArrays(new Object[]{nb.q, str}, objArr));
+    }
+
+    public static void failAsync(YLogger yLogger, Throwable th, String str, Object... objArr) {
+        yLogger.w("ASYNC.ERROR", concatArrays(new Object[]{nb.q, str}, concatArrays(objArr, new Object[]{"e", th})));
+    }
+
+    private static Object[] concatArrays(Object[] objArr, Object[] objArr2) {
+        if (objArr2 == null || objArr2.length == 0) {
+            return objArr;
+        }
+        if (objArr == null || objArr.length == 0) {
+            return objArr2;
+        }
+        Object[] objArr3 = new Object[objArr.length + objArr2.length];
+        System.arraycopy(objArr, 0, objArr3, 0, objArr.length);
+        System.arraycopy(objArr2, 0, objArr3, objArr.length, objArr2.length);
+        return objArr3;
+    }
+
+    public static void cpuFamily(YLogger yLogger) {
+        yLogger.i("CPU.FAMILY", "ARCH", System.getProperty("os.arch"), "SUPPORTED_ABIS", Arrays.toString(Build.SUPPORTED_ABIS));
+    }
+}