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

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

@@ -0,0 +1,119 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import java.net.UnknownHostException;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public class Common {
+    private static Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public static <T> T or(T t, T t2) {
+        return t != null ? t : t2;
+    }
+
+    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 UnknownHostException unknownHostCause(Throwable th) {
+        while (th != null) {
+            if (!(th instanceof UnknownHostException)) {
+                th = th.getCause();
+            } else {
+                return (UnknownHostException) th;
+            }
+        }
+        return null;
+    }
+
+    public static String emptyToNull(String str) {
+        if (str == null || str.length() > 0) {
+            return str;
+        }
+        return null;
+    }
+
+    public static String printBytes(byte[] bArr, int i, int i2) {
+        StringBuilder sb = new StringBuilder();
+        while (i < i2) {
+            sb.append(String.format("%02x", Byte.valueOf(bArr[i])));
+            i++;
+        }
+        return sb.toString();
+    }
+
+    public static Looper createLooper() {
+        return createLooper("looper");
+    }
+
+    public static Looper createLooper(String str) {
+        HandlerThread handlerThread = new HandlerThread(str);
+        handlerThread.start();
+        return handlerThread.getLooper();
+    }
+
+    public static <T> T call(Callable<T> callable) {
+        try {
+            return callable.call();
+        } catch (Exception e) {
+            throw propagate(e);
+        }
+    }
+
+    public static long packageVersionCode(Context context) {
+        long longVersionCode;
+        try {
+            PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+            if (Build.VERSION.SDK_INT >= 28) {
+                longVersionCode = packageInfo.getLongVersionCode();
+                return longVersionCode;
+            }
+            return packageInfo.versionCode;
+        } catch (PackageManager.NameNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    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");
+        }
+    }
+}

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

@@ -0,0 +1,183 @@
+package com.glu.plugins.gluanalytics.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: classes2.dex */
+public class ConfigUtil {
+    public static Boolean getNullableBoolean(@Nullable Object obj, @NonNull String str, Boolean bool) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return bool;
+        }
+        if (object instanceof Boolean) {
+            return Boolean.valueOf(((Boolean) object).booleanValue());
+        }
+        if (object instanceof String) {
+            String str2 = (String) object;
+            if (TextUtils.equals(str2, "true")) {
+                return Boolean.TRUE;
+            }
+            if (TextUtils.equals(str2, "false")) {
+                return Boolean.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 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 getNullableLong(@Nullable Object obj, @NonNull String str, Long l) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return l;
+        }
+        if (object instanceof Number) {
+            return Long.valueOf(((Number) object).longValue());
+        }
+        if (object instanceof String) {
+            return Long.valueOf(Long.parseLong((String) object));
+        }
+        throw new IllegalArgumentException("Unsupported type for long 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/com/glu/plugins/gluanalytics/util/Conversion.java

@@ -0,0 +1,20 @@
+package com.glu.plugins.gluanalytics.util;
+
+import java.math.BigDecimal;
+
+/* loaded from: classes2.dex */
+public class Conversion {
+    private static final BigDecimal HUNDRED_AS_DECIMAL = new BigDecimal(100);
+
+    public static double centsToUsd(long j) {
+        return j * 0.01d;
+    }
+
+    public static long usdToCents(double d) {
+        return (long) ((d * 100.0d) + 0.5d);
+    }
+
+    public static BigDecimal usdToCentsInDecimal(double d) {
+        return BigDecimal.valueOf(d).multiply(HUNDRED_AS_DECIMAL);
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.glu.plugins.gluanalytics.util;
+
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import javax.crypto.Mac;
+import javax.crypto.ShortBufferException;
+import javax.crypto.spec.SecretKeySpec;
+
+/* loaded from: classes2.dex */
+public class Crypto {
+    public static void hmacSHA256(byte[] bArr, int i, int i2, byte[] bArr2, byte[] bArr3, int i3) throws InvalidKeyException, NoSuchAlgorithmException, ShortBufferException {
+        SecretKeySpec secretKeySpec = new SecretKeySpec(bArr2, "HmacSHA256");
+        Mac mac = Mac.getInstance("HmacSHA256");
+        mac.init(secretKeySpec);
+        mac.update(bArr, i, i2);
+        mac.doFinal(bArr3, i3);
+    }
+}

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

@@ -0,0 +1,22 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.Intent;
+import android.content.IntentFilter;
+import java.util.UUID;
+
+/* loaded from: classes2.dex */
+public class DummyEventBus implements EventBus {
+    public static final EventBus INSTANCE = new DummyEventBus();
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void publish(Intent intent) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void subscribe(UUID uuid, Subscriber subscriber, Iterable<IntentFilter> iterable) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void unsubscribe(UUID uuid) {
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.Intent;
+import android.content.IntentFilter;
+import java.util.UUID;
+
+/* loaded from: classes2.dex */
+public interface EventBus {
+    void publish(Intent intent);
+
+    void subscribe(UUID uuid, Subscriber subscriber, Iterable<IntentFilter> iterable);
+
+    void unsubscribe(UUID uuid);
+}

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

@@ -0,0 +1,89 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.os.Bundle;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public class GluActivityLifecycleCallbacks 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 GluActivityLifecycleCallbacks(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() {
+        Common.runOnUIThread(new Runnable() { // from class: com.glu.plugins.gluanalytics.util.GluActivityLifecycleCallbacks.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (GluActivityLifecycleCallbacks.this.mApplication != null) {
+                    GluActivityLifecycleCallbacks.this.mApplication.unregisterActivityLifecycleCallbacks(this);
+                }
+                GluActivityLifecycleCallbacks.this.mApplication = null;
+                GluActivityLifecycleCallbacks.this.mOnActivityCallback = null;
+                GluActivityLifecycleCallbacks.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/com/glu/plugins/gluanalytics/util/GoogleAdvertisingIDUtil.java

@@ -0,0 +1,175 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.glu.plugins.gluanalytics.AnalyticsData;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/* loaded from: classes2.dex */
+public class GoogleAdvertisingIDUtil {
+    private static final String ADVERTISING_ID_SERVICE_NAME = "com.google.android.gms.ads.identifier.internal.IAdvertisingIdService";
+
+    public static AnalyticsData.AdvertisingIdInfo getAdvertisingIdInfo(Context context) {
+        AnalyticsData.AdvertisingIdInfo advertisingIdInfo = AnalyticsData.getAdvertisingIdInfo(context);
+        return (advertisingIdInfo == null || isAdvertisingIDEmpty(advertisingIdInfo)) ? getAdvertisingIDByBackupMethod(context) : advertisingIdInfo;
+    }
+
+    private static boolean isAdvertisingIDEmpty(AnalyticsData.AdvertisingIdInfo advertisingIdInfo) {
+        return advertisingIdInfo != null && TextUtils.isEmpty(advertisingIdInfo.advertisingId);
+    }
+
+    private static AnalyticsData.AdvertisingIdInfo getAdvertisingIDByBackupMethod(Context context) {
+        try {
+            return queryAdvertisingIDFromService(context);
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    private static AnalyticsData.AdvertisingIdInfo queryAdvertisingIDFromService(Context context) {
+        boolean z;
+        GoogleAdvertisingServiceConnection googleAdvertisingServiceConnection = new GoogleAdvertisingServiceConnection();
+        Intent intent = new Intent("com.google.android.gms.ads.identifier.service.START");
+        intent.setPackage("com.google.android.gms");
+        try {
+            z = context.bindService(intent, googleAdvertisingServiceConnection, 1);
+        } catch (Throwable unused) {
+            z = false;
+        }
+        if (z) {
+            try {
+                GoogleAdvertisingInfo create = GoogleAdvertisingInfo.GoogleAdvertisingInfoBinder.create(googleAdvertisingServiceConnection.getBinder());
+                AnalyticsData.AdvertisingIdInfo advertisingIdInfo = new AnalyticsData.AdvertisingIdInfo(create.getId(), create.getEnabled(true));
+                if (z) {
+                    context.unbindService(googleAdvertisingServiceConnection);
+                }
+                return advertisingIdInfo;
+            } catch (Throwable unused2) {
+                if (!z) {
+                    return null;
+                }
+            }
+        } else if (!z) {
+            return null;
+        }
+        context.unbindService(googleAdvertisingServiceConnection);
+        return null;
+    }
+
+    public interface GoogleAdvertisingInfo extends IInterface {
+        boolean getEnabled(boolean z) throws RemoteException;
+
+        String getId() throws RemoteException;
+
+        public static abstract class GoogleAdvertisingInfoBinder extends Binder implements GoogleAdvertisingInfo {
+            public static GoogleAdvertisingInfo create(IBinder iBinder) {
+                if (iBinder == null) {
+                    return null;
+                }
+                IInterface queryLocalInterface = iBinder.queryLocalInterface(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                if (queryLocalInterface instanceof GoogleAdvertisingInfo) {
+                    return (GoogleAdvertisingInfo) queryLocalInterface;
+                }
+                return new GoogleAdvertisingInfoImplementation(iBinder);
+            }
+
+            @Override // android.os.Binder
+            public boolean onTransact(int i, @NonNull Parcel parcel, Parcel parcel2, int i2) throws RemoteException {
+                if (i == 1) {
+                    parcel.enforceInterface(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                    String id = getId();
+                    parcel2.writeNoException();
+                    parcel2.writeString(id);
+                    return true;
+                }
+                if (i == 2) {
+                    parcel.enforceInterface(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                    boolean enabled = getEnabled(parcel.readInt() != 0);
+                    parcel2.writeNoException();
+                    parcel2.writeInt(enabled ? 1 : 0);
+                    return true;
+                }
+                return super.onTransact(i, parcel, parcel2, i2);
+            }
+
+            public static class GoogleAdvertisingInfoImplementation implements GoogleAdvertisingInfo {
+                private final IBinder mBinder;
+
+                @Override // android.os.IInterface
+                public IBinder asBinder() {
+                    return this.mBinder;
+                }
+
+                public GoogleAdvertisingInfoImplementation(IBinder iBinder) {
+                    this.mBinder = iBinder;
+                }
+
+                @Override // com.glu.plugins.gluanalytics.util.GoogleAdvertisingIDUtil.GoogleAdvertisingInfo
+                public String getId() throws RemoteException {
+                    Parcel obtain = Parcel.obtain();
+                    Parcel obtain2 = Parcel.obtain();
+                    try {
+                        obtain.writeInterfaceToken(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                        this.mBinder.transact(1, obtain, obtain2, 0);
+                        obtain2.readException();
+                        return obtain2.readString();
+                    } finally {
+                        obtain2.recycle();
+                        obtain.recycle();
+                    }
+                }
+
+                @Override // com.glu.plugins.gluanalytics.util.GoogleAdvertisingIDUtil.GoogleAdvertisingInfo
+                public boolean getEnabled(boolean z) throws RemoteException {
+                    Parcel obtain = Parcel.obtain();
+                    Parcel obtain2 = Parcel.obtain();
+                    try {
+                        obtain.writeInterfaceToken(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                        obtain.writeInt(z ? 1 : 0);
+                        this.mBinder.transact(2, obtain, obtain2, 0);
+                        obtain2.readException();
+                        return obtain2.readInt() != 0;
+                    } finally {
+                        obtain2.recycle();
+                        obtain.recycle();
+                    }
+                }
+            }
+        }
+    }
+
+    public static class GoogleAdvertisingServiceConnection implements ServiceConnection {
+        private final BlockingQueue<IBinder> mBinderQueue = new LinkedBlockingQueue();
+        boolean mConsumed = false;
+
+        @Override // android.content.ServiceConnection
+        public void onServiceDisconnected(ComponentName componentName) {
+        }
+
+        @Override // android.content.ServiceConnection
+        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+            try {
+                this.mBinderQueue.put(iBinder);
+            } catch (Throwable unused) {
+            }
+        }
+
+        public IBinder getBinder() throws InterruptedException {
+            if (this.mConsumed) {
+                throw new IllegalStateException();
+            }
+            this.mConsumed = true;
+            return this.mBinderQueue.take();
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+package com.glu.plugins.gluanalytics.util;
+
+/* loaded from: classes2.dex */
+public interface IAction {
+    void apply();
+}

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

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

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

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

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

@@ -0,0 +1,304 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+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: classes2.dex */
+public class JsonUtil {
+    public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+        return Api11.parseJsonObject(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 String toJson(Object obj) {
+        JSONStringer jSONStringer = new JSONStringer();
+        try {
+            value(jSONStringer, obj);
+            return jSONStringer.toString();
+        } catch (JSONException e) {
+            throw Common.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 = CollectionUtil.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 = CollectionUtil.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 Common.propagate(e2);
+                }
+            } catch (IOException e3) {
+                e = e3;
+                throw Common.propagate(e);
+            } catch (Throwable th2) {
+                th = th2;
+                jsonReader2 = jsonReader;
+                if (jsonReader2 != null) {
+                    try {
+                        jsonReader2.close();
+                    } catch (IOException e4) {
+                        throw Common.propagate(e4);
+                    }
+                }
+                throw th;
+            }
+        }
+
+        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 JsonUtil.toMap(new JSONObject(str));
+        }
+    }
+}

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

@@ -0,0 +1,97 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.UUID;
+
+/* loaded from: classes2.dex */
+public class LocalBroadcastManagerEventBus implements EventBus {
+    private static volatile EventBus sInstance;
+    private final LocalBroadcastManager mLbm;
+    private final Map<UUID, BroadcastReceiver> mReceivers = new HashMap();
+
+    public static boolean isSupported() {
+        return true;
+    }
+
+    private LocalBroadcastManagerEventBus(Context context) {
+        this.mLbm = LocalBroadcastManager.getInstance(context);
+    }
+
+    public static EventBus getInstance(Context context) {
+        Common.require(context != null, "context can't be null.");
+        if (sInstance == null) {
+            synchronized (LocalBroadcastManagerEventBus.class) {
+                try {
+                    if (sInstance == null) {
+                        sInstance = new LocalBroadcastManagerEventBus(context);
+                    }
+                } finally {
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void subscribe(UUID uuid, Subscriber subscriber, Iterable<IntentFilter> iterable) {
+        Common.require(uuid != null, "key can't be null.");
+        Common.require(subscriber != null, "weakSubscriber can't be null.");
+        Common.require(iterable != null, "filters can't be null.");
+        unsubscribe(uuid);
+        SubscriberAdapter subscriberAdapter = new SubscriberAdapter(uuid, subscriber);
+        synchronized (this) {
+            this.mReceivers.put(uuid, subscriberAdapter);
+        }
+        Iterator<IntentFilter> it = iterable.iterator();
+        while (it.hasNext()) {
+            this.mLbm.registerReceiver(subscriberAdapter, it.next());
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void unsubscribe(UUID uuid) {
+        BroadcastReceiver remove;
+        Common.require(uuid != null, "key can't be null.");
+        synchronized (this) {
+            remove = this.mReceivers.remove(uuid);
+        }
+        if (remove != null) {
+            this.mLbm.unregisterReceiver(remove);
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void publish(Intent intent) {
+        Common.require(intent != null, "intent can't be null.");
+        this.mLbm.sendBroadcast(intent);
+    }
+
+    public class SubscriberAdapter extends BroadcastReceiver {
+        private final UUID mKey;
+        private final Reference<Subscriber> mSubscriber;
+
+        public SubscriberAdapter(UUID uuid, Subscriber subscriber) {
+            this.mKey = uuid;
+            this.mSubscriber = new WeakReference(subscriber);
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            Subscriber subscriber = this.mSubscriber.get();
+            if (subscriber != null) {
+                subscriber.onReceive(LocalBroadcastManagerEventBus.this, intent);
+            } else {
+                LocalBroadcastManagerEventBus.this.unsubscribe(this.mKey);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.Intent;
+
+/* loaded from: classes2.dex */
+public interface Subscriber {
+    void onReceive(EventBus eventBus, Intent intent);
+}

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

@@ -0,0 +1,110 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.text.TextUtils;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes2.dex */
+public class YLogger {
+    private final Logger mLog;
+
+    private YLogger(Logger logger) {
+        this.mLog = logger;
+    }
+
+    public static YLogger create(String str) {
+        return new YLogger(Logger.getLogger(str));
+    }
+
+    public static YLogger create(Class<?> cls) {
+        return create(cls.getName());
+    }
+
+    public void v(String str, Object... objArr) {
+        doLog(Level.FINEST, str, objArr);
+    }
+
+    public void i(String str, Object... objArr) {
+        doLog(Level.INFO, str, objArr);
+    }
+
+    public void e(String str, Object... objArr) {
+        doLog(Level.SEVERE, str, objArr);
+    }
+
+    public boolean canV() {
+        return this.mLog.isLoggable(Level.FINEST);
+    }
+
+    private 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 Common.propagate(e);
+        }
+    }
+
+    private 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) && obj2 != null) {
+                jSONStringer.key((String) obj).value(obj2);
+            }
+        }
+    }
+
+    private void doLog(Level level, String str, Object[] objArr) {
+        if (this.mLog.isLoggable(level)) {
+            this.mLog.log(level, format(str, objArr), findThrowable(objArr));
+        }
+    }
+}