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/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));
+    }
+}