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/glucentralservices/eventbus/CollectionUtil.java

@@ -0,0 +1,418 @@
+package csdk.glucentralservices.eventbus;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+import android.util.JsonReader;
+import android.util.JsonToken;
+import csdk.gluads.Consts;
+import java.io.StringReader;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+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: classes4.dex */
+class CollectionUtil {
+    public static final IVisitor<Object> BUILDER_LIST;
+    public static final IVisitor<Object> BUILDER_MAP;
+    public static final IVisitor<Object> BUILDER_OUTER;
+    public static final IVisitor<JSONStringer> JSON_LIST;
+    public static final IVisitor<JSONStringer> JSON_MAP;
+    public static final IVisitor<JSONStringer> JSON_OUTER;
+
+    public interface IVisitor<S> {
+        Object beginList(S s, Object obj, String str) throws Exception;
+
+        Object beginMap(S s, Object obj, String str) throws Exception;
+
+        Object endList(S s, Object obj, String str, Object obj2) throws Exception;
+
+        Object endMap(S s, Object obj, String str, Object obj2) throws Exception;
+
+        IVisitor<S> list();
+
+        IVisitor<S> map();
+
+        Object val(S s, Object obj, String str, Object obj2) throws Exception;
+    }
+
+    static {
+        JSON_MAP = new JSONStringerMapVisitor();
+        JSONStringerListVisitor jSONStringerListVisitor = new JSONStringerListVisitor();
+        JSON_LIST = jSONStringerListVisitor;
+        JSON_OUTER = jSONStringerListVisitor;
+        BUILDER_MAP = new BuilderMapVisitor();
+        BUILDER_LIST = new BuilderListVisitor();
+        BUILDER_OUTER = new BuilderOuterVisitor();
+    }
+
+    public static Map<String, Object> parseJSON(String str) throws JSONException {
+        return Api11.parseJsonObject(str);
+    }
+
+    public static Map<String, Object> toMap(Object obj) {
+        try {
+            return (Map) visit(obj, BUILDER_OUTER, null, null, null);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String toJSON(Object obj) throws JSONException {
+        JSONStringer jSONStringer = new JSONStringer();
+        jsonValue(jSONStringer, obj);
+        return jSONStringer.toString();
+    }
+
+    public static void jsonValue(JSONStringer jSONStringer, Object obj) throws JSONException {
+        try {
+            visit(obj, JSON_OUTER, jSONStringer, null, null);
+        } catch (JSONException e) {
+            throw e;
+        } catch (Exception e2) {
+            throw new RuntimeException(e2);
+        }
+    }
+
+    public static <S> Object visit(Object obj, IVisitor<S> iVisitor, S s, Object obj2, String str) throws Exception {
+        if (obj == null || (obj instanceof Number) || (obj instanceof Boolean)) {
+            return iVisitor.val(s, obj2, str, obj);
+        }
+        if ((obj instanceof CharSequence) || (obj instanceof Character)) {
+            return iVisitor.val(s, obj2, str, obj.toString());
+        }
+        if (obj instanceof Map) {
+            return visitMap(iVisitor, s, obj2, str, (Map) obj);
+        }
+        if (obj instanceof Iterable) {
+            IVisitor<S> list = iVisitor.list();
+            Object beginList = iVisitor.beginList(s, obj2, str);
+            Iterator it = ((Iterable) obj).iterator();
+            while (it.hasNext()) {
+                beginList = visit(it.next(), list, s, beginList, null);
+            }
+            return iVisitor.endList(s, obj2, str, beginList);
+        }
+        int i = 0;
+        if (obj.getClass().isArray()) {
+            IVisitor<S> list2 = iVisitor.list();
+            Object beginList2 = iVisitor.beginList(s, obj2, str);
+            int length = Array.getLength(obj);
+            while (i < length) {
+                beginList2 = visit(Array.get(obj, i), list2, s, beginList2, null);
+                i++;
+            }
+            return iVisitor.endList(s, obj2, str, beginList2);
+        }
+        if (obj instanceof Bundle) {
+            IVisitor<S> map = iVisitor.map();
+            Object beginMap = iVisitor.beginMap(s, obj2, str);
+            Bundle bundle = (Bundle) obj;
+            Iterator<String> it2 = bundle.keySet().iterator();
+            while (it2.hasNext()) {
+                beginMap = visit(bundle.get(str), map, s, beginMap, it2.next());
+            }
+            return iVisitor.endMap(s, obj2, str, beginMap);
+        }
+        if (obj instanceof JSONArray) {
+            IVisitor<S> list3 = iVisitor.list();
+            Object beginList3 = iVisitor.beginList(s, obj2, str);
+            JSONArray jSONArray = (JSONArray) obj;
+            while (i < jSONArray.length()) {
+                beginList3 = visit(jSONArray.opt(i), list3, s, beginList3, null);
+                i++;
+            }
+            return iVisitor.endList(s, obj2, str, beginList3);
+        }
+        if (obj instanceof JSONObject) {
+            IVisitor<S> map2 = iVisitor.map();
+            Object beginMap2 = iVisitor.beginMap(s, obj2, str);
+            JSONObject jSONObject = (JSONObject) obj;
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                beginMap2 = visit(jSONObject.opt(str), map2, s, beginMap2, keys.next());
+            }
+            return iVisitor.endMap(s, obj2, str, beginMap2);
+        }
+        if (obj == JSONObject.NULL) {
+            return iVisitor.val(s, obj2, str, null);
+        }
+        IVisitor<S> map3 = iVisitor.map();
+        Object visit = visit(obj.getClass().getSimpleName(), map3, s, iVisitor.beginMap(s, obj2, str), "cls");
+        String collectionUtil = toString(obj);
+        if (collectionUtil != null) {
+            visit = visit(collectionUtil, map3, s, visit, "str");
+        }
+        return iVisitor.endMap(s, obj2, str, visit);
+    }
+
+    private static <S> Object visitMap(IVisitor<S> iVisitor, S s, Object obj, String str, Map<?, ?> map) throws Exception {
+        Iterator<?> it = map.keySet().iterator();
+        while (it.hasNext()) {
+            if (!(it.next() instanceof CharSequence)) {
+                return visitMapWithNonStringKeys(iVisitor, s, obj, str, map);
+            }
+        }
+        IVisitor<S> map2 = iVisitor.map();
+        Object beginMap = iVisitor.beginMap(s, obj, str);
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            beginMap = visit(entry.getValue(), map2, s, beginMap, entry.getKey().toString());
+        }
+        return iVisitor.endMap(s, obj, str, beginMap);
+    }
+
+    private static <S> Object visitMapWithNonStringKeys(IVisitor<S> iVisitor, S s, Object obj, String str, Map<?, ?> map) throws Exception {
+        IVisitor<S> map2 = iVisitor.map();
+        Object visit = visit("flatmap", map2, s, iVisitor.beginMap(s, obj, str), "cls");
+        IVisitor<S> list = iVisitor.list();
+        Object beginList = map2.beginList(s, visit, Consts.KEY_TAPJOY_USER_ID_VERSION);
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            visit(entry.getKey(), list, s, beginList, null);
+            visit(entry.getValue(), list, s, beginList, null);
+        }
+        map2.endList(s, visit, Consts.KEY_TAPJOY_USER_ID_VERSION, beginList);
+        return iVisitor.endMap(s, obj, str, visit);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static <K, V> Map<K, V> createMap() {
+        return new HashMap();
+    }
+
+    private static String toString(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        if (obj instanceof Throwable) {
+            return ((Throwable) obj).getMessage();
+        }
+        return obj.toString();
+    }
+
+    public static abstract class JSONStringerBaseVisitor implements IVisitor<JSONStringer> {
+        private JSONStringerBaseVisitor() {
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object endMap(JSONStringer jSONStringer, Object obj, String str, Object obj2) throws JSONException {
+            return jSONStringer.endObject();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object endList(JSONStringer jSONStringer, Object obj, String str, Object obj2) throws JSONException {
+            return jSONStringer.endArray();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public IVisitor<JSONStringer> map() {
+            return CollectionUtil.JSON_MAP;
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public IVisitor<JSONStringer> list() {
+            return CollectionUtil.JSON_LIST;
+        }
+    }
+
+    public static class JSONStringerMapVisitor extends JSONStringerBaseVisitor {
+        private JSONStringerMapVisitor() {
+            super();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginMap(JSONStringer jSONStringer, Object obj, String str) throws JSONException {
+            return jSONStringer.key(str).object();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginList(JSONStringer jSONStringer, Object obj, String str) throws JSONException {
+            return jSONStringer.key(str).array();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(JSONStringer jSONStringer, Object obj, String str, Object obj2) throws JSONException {
+            return jSONStringer.key(str).value(obj2);
+        }
+    }
+
+    public static class JSONStringerListVisitor extends JSONStringerBaseVisitor {
+        private JSONStringerListVisitor() {
+            super();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginMap(JSONStringer jSONStringer, Object obj, String str) throws JSONException {
+            return jSONStringer.object();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginList(JSONStringer jSONStringer, Object obj, String str) throws JSONException {
+            return jSONStringer.array();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(JSONStringer jSONStringer, Object obj, String str, Object obj2) throws JSONException {
+            return jSONStringer.value(obj2);
+        }
+    }
+
+    public static abstract class BuilderBaseVisitor implements IVisitor<Object> {
+        private BuilderBaseVisitor() {
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginMap(Object obj, Object obj2, String str) {
+            return CollectionUtil.createMap();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object endMap(Object obj, Object obj2, String str, Object obj3) throws Exception {
+            return val(obj, obj2, str, obj3);
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object beginList(Object obj, Object obj2, String str) {
+            return new ArrayList();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object endList(Object obj, Object obj2, String str, Object obj3) throws Exception {
+            return val(obj, obj2, str, obj3);
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public IVisitor<Object> map() {
+            return CollectionUtil.BUILDER_MAP;
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public IVisitor<Object> list() {
+            return CollectionUtil.BUILDER_LIST;
+        }
+    }
+
+    public static class BuilderMapVisitor extends BuilderBaseVisitor {
+        private BuilderMapVisitor() {
+            super();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(Object obj, Object obj2, String str, Object obj3) {
+            Map map = (Map) obj2;
+            map.put(str, obj3);
+            return map;
+        }
+    }
+
+    public static class BuilderListVisitor extends BuilderBaseVisitor {
+        private BuilderListVisitor() {
+            super();
+        }
+
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(Object obj, Object obj2, String str, Object obj3) {
+            List list = (List) obj2;
+            list.add(obj3);
+            return list;
+        }
+    }
+
+    public static class BuilderOuterVisitor extends BuilderBaseVisitor {
+        @Override // csdk.glucentralservices.eventbus.CollectionUtil.IVisitor
+        public Object val(Object obj, Object obj2, String str, Object obj3) {
+            return obj3;
+        }
+
+        private BuilderOuterVisitor() {
+            super();
+        }
+    }
+
+    @TargetApi(11)
+    public static class Api11 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            return (Map) parseJsonValue(str, CollectionUtil.BUILDER_OUTER, null);
+        }
+
+        public static <S> Object parseJsonValue(String str, IVisitor<S> iVisitor, S s) throws JSONException {
+            try {
+                JsonReader jsonReader = new JsonReader(new StringReader(str));
+                jsonReader.setLenient(true);
+                return parseJsonValue(jsonReader, iVisitor, s, null, null);
+            } catch (JSONException e) {
+                throw e;
+            } catch (Exception e2) {
+                throw new RuntimeException(e2);
+            }
+        }
+
+        public static <S> Object parseJsonValue(JsonReader jsonReader, IVisitor<S> iVisitor, S s, Object obj, String str) throws Exception {
+            JsonToken peek = jsonReader.peek();
+            if (peek == JsonToken.BEGIN_OBJECT) {
+                return parseJsonObject(jsonReader, iVisitor, s, obj, str);
+            }
+            if (peek == JsonToken.BEGIN_ARRAY) {
+                return parseJsonArray(jsonReader, iVisitor, s, obj, str);
+            }
+            if (peek == JsonToken.BOOLEAN) {
+                return iVisitor.val(s, obj, str, Boolean.valueOf(jsonReader.nextBoolean()));
+            }
+            if (peek == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return iVisitor.val(s, obj, str, null);
+            }
+            if (peek == JsonToken.NUMBER) {
+                String nextString = jsonReader.nextString();
+                if (nextString.contains(Consts.STRING_PERIOD) || nextString.contains("e") || nextString.contains("E")) {
+                    return iVisitor.val(s, obj, str, Double.valueOf(Double.parseDouble(nextString)));
+                }
+                return iVisitor.val(s, obj, str, Long.valueOf(Long.parseLong(nextString)));
+            }
+            if (peek == JsonToken.STRING) {
+                return iVisitor.val(s, obj, str, jsonReader.nextString());
+            }
+            throw new JSONException("Unexpected token " + peek);
+        }
+
+        public static <S> Object parseJsonObject(JsonReader jsonReader, IVisitor<S> iVisitor, S s, Object obj, String str) throws Exception {
+            jsonReader.beginObject();
+            IVisitor<S> map = iVisitor.map();
+            Object beginMap = iVisitor.beginMap(s, obj, str);
+            while (true) {
+                JsonToken peek = jsonReader.peek();
+                if (peek == JsonToken.END_OBJECT) {
+                    jsonReader.endObject();
+                    return iVisitor.endMap(s, obj, str, beginMap);
+                }
+                if (peek == JsonToken.NAME) {
+                    beginMap = parseJsonValue(jsonReader, map, s, beginMap, jsonReader.nextName());
+                } else {
+                    throw new JSONException("Expected } or name but found " + peek);
+                }
+            }
+        }
+
+        public static <S> Object parseJsonArray(JsonReader jsonReader, IVisitor<S> iVisitor, S s, Object obj, String str) throws Exception {
+            jsonReader.beginArray();
+            IVisitor<S> list = iVisitor.list();
+            Object beginList = iVisitor.beginList(s, obj, str);
+            while (jsonReader.peek() != JsonToken.END_ARRAY) {
+                beginList = parseJsonValue(jsonReader, list, s, beginList, null);
+            }
+            jsonReader.endArray();
+            return iVisitor.endList(s, obj, str, beginList);
+        }
+    }
+
+    public static class Api1 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            return CollectionUtil.toMap(new JSONObject(str));
+        }
+    }
+}

decompiled/sources/csdk/glucentralservices/eventbus/EventHandlerData.java

@@ -0,0 +1,12 @@
+package csdk.glucentralservices.eventbus;
+
+/* loaded from: classes4.dex */
+class EventHandlerData {
+    public final IServerEventBus eventBus;
+    public final IServerEventHandler handler;
+
+    public EventHandlerData(IServerEventBus iServerEventBus, IServerEventHandler iServerEventHandler) {
+        this.eventBus = iServerEventBus;
+        this.handler = iServerEventHandler;
+    }
+}

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

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

decompiled/sources/csdk/glucentralservices/eventbus/IServerEventBus.java

@@ -0,0 +1,15 @@
+package csdk.glucentralservices.eventbus;
+
+import java.util.Collection;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface IServerEventBus {
+    Object globalToken();
+
+    void publish(Object obj, Map<String, Object> map);
+
+    Object subscribe(Object obj, String str, Collection<String> collection, IServerEventHandler iServerEventHandler);
+
+    void unsubscribe(Object obj);
+}

decompiled/sources/csdk/glucentralservices/eventbus/IServerEventHandler.java

@@ -0,0 +1,8 @@
+package csdk.glucentralservices.eventbus;
+
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface IServerEventHandler {
+    void handleEvent(IServerEventBus iServerEventBus, Object obj, String str, Map<String, Object> map) throws Exception;
+}

decompiled/sources/csdk/glucentralservices/eventbus/ServerEvent.java

@@ -0,0 +1,118 @@
+package csdk.glucentralservices.eventbus;
+
+import androidx.annotation.NonNull;
+import com.firemonkeys.cloudcellapi.LocalNotificationsCenter;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+class ServerEvent implements Map<String, Object> {
+    private static final Set<String> KEYS = createKeys();
+    public final String action;
+    public final String channel;
+    public final Map<String, Object> data;
+    public final String sender;
+
+    @Override // java.util.Map
+    @NonNull
+    public Set<String> keySet() {
+        return KEYS;
+    }
+
+    public ServerEvent(String str, String str2, String str3, Map<String, Object> map) {
+        this.channel = str;
+        this.action = str2;
+        this.sender = str3;
+        this.data = map;
+    }
+
+    @Override // java.util.Map
+    public int size() {
+        return keySet().size();
+    }
+
+    @Override // java.util.Map
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    @Override // java.util.Map
+    public boolean containsKey(Object obj) {
+        return KEYS.contains(obj);
+    }
+
+    @Override // java.util.Map
+    public boolean containsValue(Object obj) {
+        return values().contains(obj);
+    }
+
+    @Override // java.util.Map
+    public Object get(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        if (obj.equals(LocalNotificationsCenter.EXTRA_CHANNEL_ID)) {
+            return this.channel;
+        }
+        if (obj.equals("action")) {
+            return this.action;
+        }
+        if (obj.equals("sender")) {
+            return this.sender;
+        }
+        if (obj.equals("data")) {
+            return this.data;
+        }
+        return null;
+    }
+
+    @Override // java.util.Map
+    public Object put(String str, Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Map
+    public Object remove(Object obj) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Map
+    public void putAll(@NonNull Map<? extends String, ? extends Object> map) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Map
+    public void clear() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // java.util.Map
+    @NonNull
+    public Collection<Object> values() {
+        return Arrays.asList(this.channel, this.action, this.sender, this.data);
+    }
+
+    @Override // java.util.Map
+    @NonNull
+    public Set<Map.Entry<String, Object>> entrySet() {
+        HashSet hashSet = new HashSet();
+        hashSet.add(new AbstractMap.SimpleImmutableEntry(LocalNotificationsCenter.EXTRA_CHANNEL_ID, this.channel));
+        hashSet.add(new AbstractMap.SimpleImmutableEntry("action", this.action));
+        hashSet.add(new AbstractMap.SimpleImmutableEntry("sender", this.sender));
+        hashSet.add(new AbstractMap.SimpleImmutableEntry("data", this.data));
+        return hashSet;
+    }
+
+    private static Set<String> createKeys() {
+        HashSet hashSet = new HashSet();
+        hashSet.add(LocalNotificationsCenter.EXTRA_CHANNEL_ID);
+        hashSet.add("action");
+        hashSet.add("sender");
+        hashSet.add("data");
+        return hashSet;
+    }
+}

decompiled/sources/csdk/glucentralservices/eventbus/ServerEventBus.java

@@ -0,0 +1,178 @@
+package csdk.glucentralservices.eventbus;
+
+import android.text.TextUtils;
+import com.firemonkeys.cloudcellapi.LocalNotificationsCenter;
+import java.util.Collection;
+import java.util.Map;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class ServerEventBus implements IServerEventBus {
+    private static final int RES_BAD_JSON_DATA = 2;
+    private static final int RES_ERROR = 3;
+    private static final int RES_OK = 0;
+    private static final ServerEventBus SHARED = createShared();
+    private final long mEventBus;
+    private final Object mGlobalToken;
+    private final long mMIDHandleEvent = getMIDHandleEvent();
+
+    private static native long getMIDHandleEvent();
+
+    public static IServerEventBus getShared() {
+        return SHARED;
+    }
+
+    private static native long globalToken(long j);
+
+    private static native void publish(long j, long j2, String str, String str2, String str3, String str4);
+
+    private static native void publishError(long j, long j2, String str, String str2, String str3, String str4, String str5, String str6, String str7);
+
+    private static native long shared();
+
+    private static native long subscribe(long j, long j2, long j3, String str, String[] strArr, EventHandlerData eventHandlerData);
+
+    private static native void unsubscribe(long j, long j2);
+
+    @Override // csdk.glucentralservices.eventbus.IServerEventBus
+    public Object globalToken() {
+        return this.mGlobalToken;
+    }
+
+    private ServerEventBus(long j) {
+        this.mEventBus = j;
+        this.mGlobalToken = tokenFromNativeToken(globalToken(j));
+    }
+
+    @Override // csdk.glucentralservices.eventbus.IServerEventBus
+    public Object subscribe(Object obj, String str, Collection<String> collection, IServerEventHandler iServerEventHandler) {
+        String[] strArr;
+        if (collection != null) {
+            strArr = new String[collection.size()];
+            collection.toArray(strArr);
+        } else {
+            strArr = null;
+        }
+        return tokenFromNativeToken(subscribe(this.mEventBus, nativeTokenFromToken(obj), this.mMIDHandleEvent, str, strArr, new EventHandlerData(this, iServerEventHandler)));
+    }
+
+    @Override // csdk.glucentralservices.eventbus.IServerEventBus
+    public void unsubscribe(Object obj) {
+        unsubscribe(this.mEventBus, nativeTokenFromToken(obj));
+    }
+
+    @Override // csdk.glucentralservices.eventbus.IServerEventBus
+    public void publish(Object obj, Map<String, Object> map) {
+        Exception exc;
+        String str;
+        String str2;
+        String str3;
+        String json;
+        String str4;
+        String str5;
+        String str6;
+        if (map != null) {
+            try {
+                String str7 = (String) map.get(LocalNotificationsCenter.EXTRA_CHANNEL_ID);
+                try {
+                    String str8 = (String) map.get("action");
+                    try {
+                        String str9 = (String) map.get("sender");
+                        try {
+                            Map map2 = (Map) map.get("data");
+                            json = map2 != null ? CollectionUtil.toJSON(map2) : null;
+                            str4 = str7;
+                            str5 = str8;
+                            str6 = str9;
+                        } catch (Exception e) {
+                            exc = e;
+                            str = str7;
+                            str2 = str8;
+                            str3 = str9;
+                            publishError(this.mEventBus, nativeTokenFromToken(obj), null, exc, str, str2, str3, null);
+                            return;
+                        }
+                    } catch (Exception e2) {
+                        exc = e2;
+                        str3 = null;
+                        str = str7;
+                        str2 = str8;
+                    }
+                } catch (Exception e3) {
+                    exc = e3;
+                    str2 = null;
+                    str3 = null;
+                    str = str7;
+                }
+            } catch (Exception e4) {
+                exc = e4;
+                str = null;
+                str2 = null;
+                str3 = null;
+            }
+        } else {
+            str4 = null;
+            str5 = null;
+            str6 = null;
+            json = null;
+        }
+        publish(this.mEventBus, nativeTokenFromToken(obj), str4, str5, str6, json);
+    }
+
+    private static ServerEventBus createShared() {
+        try {
+            System.loadLibrary("glucentralservices");
+        } catch (UnsatisfiedLinkError unused) {
+        }
+        return new ServerEventBus(shared());
+    }
+
+    private static int handleEvent(long j, long j2, String str, String str2, String str3, String str4, String str5, EventHandlerData eventHandlerData) {
+        try {
+            return doHandleEvent(j, j2, str, str2, str3, str4, str5, eventHandlerData);
+        } catch (Exception e) {
+            publishError(j, j2, str, "critical", e.getMessage(), str2, str3, str4, str5);
+            return 3;
+        }
+    }
+
+    private static int doHandleEvent(long j, long j2, String str, String str2, String str3, String str4, String str5, EventHandlerData eventHandlerData) throws Exception {
+        Map<String, Object> parseJSON;
+        if (TextUtils.isEmpty(str5)) {
+            parseJSON = null;
+        } else {
+            try {
+                parseJSON = CollectionUtil.parseJSON(str5);
+            } catch (JSONException unused) {
+                return 2;
+            }
+        }
+        try {
+        } catch (Exception e) {
+            e = e;
+        }
+        try {
+            eventHandlerData.handler.handleEvent(eventHandlerData.eventBus, tokenFromNativeToken(j2), str, new ServerEvent(str2, str3, str4, parseJSON));
+            return 0;
+        } catch (Exception e2) {
+            e = e2;
+            publishError(j, j2, str, e, str2, str3, str4, str5);
+            return 3;
+        }
+    }
+
+    private static Object tokenFromNativeToken(long j) {
+        return Long.valueOf(j);
+    }
+
+    private static long nativeTokenFromToken(Object obj) {
+        if (obj != null) {
+            return ((Long) obj).longValue();
+        }
+        return 0L;
+    }
+
+    private static void publishError(long j, long j2, String str, Throwable th, String str2, String str3, String str4, String str5) {
+        publishError(j, j2, str, th.getClass().getName(), th.getMessage(), str2, str3, str4, str5);
+    }
+}