Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/glu/plugins/gluanalytics/util/CollectionUtil.java

@@ -0,0 +1,339 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.JsonReader;
+import android.util.JsonToken;
+import com.applovin.impl.f;
+import csdk.gluads.Consts;
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONStringer;
+
+/* loaded from: classes2.dex */
+public class CollectionUtil {
+    public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+        return Api11.parseJsonObject(str);
+    }
+
+    public static void putIfNotEmpty(JSONStringer jSONStringer, String str, String str2) throws JSONException {
+        if (TextUtils.isEmpty(str2)) {
+            return;
+        }
+        jSONStringer.key(str).value(str2);
+    }
+
+    public static void putIfNotNull(JSONStringer jSONStringer, String str, Object obj) throws JSONException {
+        if (obj != null) {
+            jSONStringer.key(str);
+            addValue(jSONStringer, obj);
+        }
+    }
+
+    public static void putIf(Map<String, Object> map, boolean z, String str, Object obj) {
+        if (z) {
+            map.put(str, obj);
+        }
+    }
+
+    public static void putIfNotEmpty(Map<String, ? super String> map, String str, String str2) {
+        if (TextUtils.isEmpty(str2)) {
+            return;
+        }
+        map.put(str, str2);
+    }
+
+    public static void putIfNotNull(Map<String, Object> map, String str, Object obj) {
+        if (obj != null) {
+            map.put(str, obj);
+        }
+    }
+
+    public static void putAll(Map<String, Object> map, Map<String, ?> map2) {
+        if (map2 != null) {
+            map.putAll(map2);
+        }
+    }
+
+    public static void putAll(JSONStringer jSONStringer, Map<String, ?> map) throws JSONException {
+        for (Map.Entry<String, ?> entry : map.entrySet()) {
+            jSONStringer.key(entry.getKey());
+            addValue(jSONStringer, entry.getValue());
+        }
+    }
+
+    public static void addAll(JSONStringer jSONStringer, Collection<?> collection) throws JSONException {
+        Iterator<?> it = collection.iterator();
+        while (it.hasNext()) {
+            addValue(jSONStringer, it.next());
+        }
+    }
+
+    public static void addValue(JSONStringer jSONStringer, Object obj) throws JSONException {
+        if (obj instanceof Map) {
+            jSONStringer.object();
+            putAll(jSONStringer, (Map<String, ?>) obj);
+            jSONStringer.endObject();
+        } else {
+            if (obj instanceof List) {
+                jSONStringer.array();
+                addAll(jSONStringer, (Collection) obj);
+                jSONStringer.endArray();
+                return;
+            }
+            jSONStringer.value(obj);
+        }
+    }
+
+    public static void writeSanitizedList(JSONStringer jSONStringer, List<?> list) throws JSONException {
+        jSONStringer.array();
+        for (Object obj : list) {
+            if (obj instanceof Map) {
+                writeSanitizedMap(jSONStringer, (Map) obj);
+            } else if (obj instanceof List) {
+                writeSanitizedList(jSONStringer, (List) obj);
+            } else {
+                writeSanitizedValue(jSONStringer, obj);
+            }
+        }
+        jSONStringer.endArray();
+    }
+
+    public static void writeSanitizedMap(JSONStringer jSONStringer, Map<String, ?> map) throws JSONException {
+        jSONStringer.object();
+        for (Map.Entry<String, ?> entry : map.entrySet()) {
+            Object value = entry.getValue();
+            if (value != null) {
+                if (value instanceof String) {
+                    String str = (String) value;
+                    if (str.length() > 0) {
+                        jSONStringer.key(entry.getKey()).value(str);
+                    }
+                } else if (value instanceof Map) {
+                    Map map2 = (Map) value;
+                    if (!isEmpty((Map<?, ?>) map2)) {
+                        jSONStringer.key(entry.getKey());
+                        writeSanitizedMap(jSONStringer, map2);
+                    }
+                } else if (value instanceof List) {
+                    List list = (List) value;
+                    if (!isEmpty((List<?>) list)) {
+                        jSONStringer.key(entry.getKey());
+                        writeSanitizedList(jSONStringer, list);
+                    }
+                } else {
+                    jSONStringer.key(entry.getKey());
+                    writeSanitizedValue(jSONStringer, value);
+                }
+            }
+        }
+        jSONStringer.endObject();
+    }
+
+    public static boolean isEmpty(List<?> list) {
+        return list.isEmpty();
+    }
+
+    public static boolean isEmpty(Map<?, ?> map) {
+        if (map.isEmpty()) {
+            return true;
+        }
+        for (Object obj : map.values()) {
+            if (obj != null) {
+                if (obj instanceof Map) {
+                    if (!isEmpty((Map<?, ?>) obj)) {
+                        return false;
+                    }
+                } else if (obj instanceof List) {
+                    if (!isEmpty((List<?>) obj)) {
+                        return false;
+                    }
+                } else if (!(obj instanceof String) || ((String) obj).length() > 0) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    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 <K, V> Map<K, V> createMap() {
+        return new HashMap();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public static <K, V> Map<K, V> createMap(Object... objArr) {
+        f.b bVar = (Map<K, V>) createMap();
+        int length = objArr.length;
+        for (int i = 0; i < length; i += 2) {
+            bVar.put(objArr[i], objArr[i + 1]);
+        }
+        return bVar;
+    }
+
+    public static <K, V> Map<K, V> shallowClone(Map<K, V> map) {
+        Map<K, V> createMap = createMap();
+        if (map != null) {
+            createMap.putAll(map);
+        }
+        return createMap;
+    }
+
+    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 = 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 = 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()));
+    }
+
+    private static void writeSanitizedValue(JSONStringer jSONStringer, Object obj) throws JSONException {
+        if (obj instanceof Boolean) {
+            jSONStringer.value(((Boolean) obj).booleanValue() ? 1L : 0L);
+        } else {
+            jSONStringer.value(obj);
+        }
+    }
+
+    @TargetApi(11)
+    public static class Api11 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            try {
+                JsonReader jsonReader = new JsonReader(new StringReader(str));
+                jsonReader.setLenient(true);
+                return parseJsonObject(jsonReader);
+            } catch (IOException e) {
+                throw Common.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 = CollectionUtil.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 CollectionUtil.toMap(new JSONObject(str));
+        }
+    }
+}