Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/com/helpshift/user/UserManager.java

@@ -0,0 +1,378 @@
+package com.helpshift.user;
+
+import com.applovin.impl.sdk.utils.JsonUtils;
+import com.helpshift.concurrency.HSThreadingService;
+import com.helpshift.log.HSLogger;
+import com.helpshift.notification.CoreNotificationManager;
+import com.helpshift.notification.HSPushTokenManager;
+import com.helpshift.poller.ConversationPoller;
+import com.helpshift.poller.FetchNotificationUpdate;
+import com.helpshift.storage.HSGenericDataManager;
+import com.helpshift.storage.HSPersistentStorage;
+import com.helpshift.user_lifecyle.UserLifecycleListener;
+import com.helpshift.util.Utils;
+import com.helpshift.util.ValueListener;
+import com.helpshift.util.ValuePair;
+import com.mbridge.msdk.newreward.function.common.MBridgeCommon;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes3.dex */
+public class UserManager {
+    public ConversationPoller conversationPoller;
+    public FetchNotificationUpdate fetchNotificationUpdate;
+    public final HSGenericDataManager genericDataManager;
+    public final HSThreadingService hsThreadingService;
+    public final CoreNotificationManager notificationManager;
+    public final HSPersistentStorage persistentStorage;
+    public final HSPushTokenManager pushTokenManager;
+    public WeakReference userLifecycleListenerRef = new WeakReference(null);
+
+    public void setConversationPoller(ConversationPoller conversationPoller) {
+        this.conversationPoller = conversationPoller;
+    }
+
+    public void setFetchNotificationUpdateFunction(FetchNotificationUpdate fetchNotificationUpdate) {
+        this.fetchNotificationUpdate = fetchNotificationUpdate;
+    }
+
+    public UserManager(HSPersistentStorage hSPersistentStorage, HSPushTokenManager hSPushTokenManager, HSGenericDataManager hSGenericDataManager, HSThreadingService hSThreadingService, CoreNotificationManager coreNotificationManager) {
+        this.persistentStorage = hSPersistentStorage;
+        this.genericDataManager = hSGenericDataManager;
+        this.pushTokenManager = hSPushTokenManager;
+        this.hsThreadingService = hSThreadingService;
+        this.notificationManager = coreNotificationManager;
+    }
+
+    public boolean retryPushTokenSync() {
+        if (isPushTokenSynced() || !shouldPoll() || Utils.isEmpty(this.persistentStorage.getCurrentPushToken())) {
+            return false;
+        }
+        this.pushTokenManager.registerPushTokenWithBackend(this.persistentStorage.getCurrentPushToken(), getActiveUserDataForNetworkCall(), new UpdatePushSyncStatus());
+        return true;
+    }
+
+    public void registerPushToken(final String str) {
+        if (shouldSyncPushToken(str)) {
+            boolean z = Utils.isNotEmpty(str) && !str.equals(this.persistentStorage.getCurrentPushToken());
+            this.pushTokenManager.savePushToken(str);
+            setPushTokenSynced(false);
+            Map loggedInUserDetails = getLoggedInUserDetails();
+            if (Utils.isEmpty(loggedInUserDetails)) {
+                loggedInUserDetails = getAnonymousUserDetails();
+            }
+            if (!Utils.isEmpty(loggedInUserDetails) && z && shouldPoll()) {
+                this.hsThreadingService.getNetworkService().submit(new Runnable() { // from class: com.helpshift.user.UserManager.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        UserManager.this.fetchNotificationUpdate.execute();
+                        if (UserManager.this.shouldPoll()) {
+                            UserManager.this.pushTokenManager.registerPushTokenWithBackend(str, UserManager.this.getActiveUserDataForNetworkCall(), UserManager.this.new UpdatePushSyncStatus());
+                        }
+                    }
+                });
+            }
+        }
+    }
+
+    public void login(Map map) {
+        if (Utils.isEmpty(map)) {
+            HSLogger.e("UsrMngr", "Empty data for user login");
+            return;
+        }
+        Map loggedInUserDetails = getLoggedInUserDetails();
+        if (Utils.isNotEmpty(loggedInUserDetails) && loggedInUserDetails.equals(map)) {
+            return;
+        }
+        if (Utils.isEmpty(loggedInUserDetails)) {
+            loggedInUserDetails = getAnonymousUserDetails();
+        }
+        this.conversationPoller.stopPoller();
+        if (isPushTokenSynced()) {
+            this.pushTokenManager.deregisterPushTokenForUser(getUserDataForNetworkCall(loggedInUserDetails), new UpdatePushSyncStatus());
+        }
+        cleanUpActiveUser();
+        this.persistentStorage.setActiveUser(new JSONObject(map).toString());
+        if (this.userLifecycleListenerRef.get() != null) {
+            ((UserLifecycleListener) this.userLifecycleListenerRef.get()).onUserDidLogin();
+        }
+        startNotificationUpdatesSync();
+    }
+
+    public void logout() {
+        Map loggedInUserDetails = getLoggedInUserDetails();
+        if (Utils.isEmpty(loggedInUserDetails)) {
+            return;
+        }
+        this.conversationPoller.stopPoller();
+        cleanUpActiveUser();
+        this.pushTokenManager.deregisterPushTokenForUser(getUserDataForNetworkCall(loggedInUserDetails), new UpdatePushSyncStatus());
+        if (getClearAnonymousUserOnLoginFlag()) {
+            removeAnonymousUser();
+            generateAndSaveAnonymousUserIdIfNeeded();
+        }
+        if (this.userLifecycleListenerRef.get() != null) {
+            ((UserLifecycleListener) this.userLifecycleListenerRef.get()).onUserDidLogout();
+        }
+        startNotificationUpdatesSync();
+    }
+
+    public final void cleanUpActiveUser() {
+        this.persistentStorage.removeActiveUser();
+        this.persistentStorage.putString("active_user_data", JsonUtils.EMPTY_JSON);
+        this.persistentStorage.setFailedAnalyticsEvents(new JSONArray());
+        this.notificationManager.cancelNotifications();
+    }
+
+    public void removeAnonymousUser() {
+        this.persistentStorage.removeAnonymousUserIdMap();
+        this.persistentStorage.putString("anon_user_data", JsonUtils.EMPTY_JSON);
+    }
+
+    public boolean getClearAnonymousUserOnLoginFlag() {
+        return this.persistentStorage.isClearAnonymousUser();
+    }
+
+    public String getActiveUserId() {
+        String userInfoForKey = getUserInfoForKey("userId");
+        if (!Utils.isEmpty(userInfoForKey)) {
+            return userInfoForKey;
+        }
+        Map anonymousUserDetails = getAnonymousUserDetails();
+        return !Utils.isEmpty(anonymousUserDetails) ? (String) anonymousUserDetails.get("userId") : userInfoForKey;
+    }
+
+    public String getActiveUserEmail() {
+        return getUserInfoForKey("userEmail");
+    }
+
+    public final String getUserInfoForKey(String str) {
+        String activeUser = this.persistentStorage.getActiveUser();
+        if (activeUser.isEmpty()) {
+            return "";
+        }
+        try {
+            return new JSONObject(activeUser).getString(str);
+        } catch (JSONException e) {
+            HSLogger.e("UsrMngr", "error in getting user info for key: " + str, e);
+            return "";
+        }
+    }
+
+    public Map getActiveUserDataForNetworkCall() {
+        Map loggedInUserDetails = getLoggedInUserDetails();
+        if (Utils.isEmpty(loggedInUserDetails)) {
+            loggedInUserDetails = getAnonymousUserDetails();
+        }
+        if (Utils.isEmpty(loggedInUserDetails)) {
+            return new HashMap();
+        }
+        return getUserDataForNetworkCall(loggedInUserDetails);
+    }
+
+    public Map getUserDataForNetworkCall(Map map) {
+        Map userDataKeyMapping = this.genericDataManager.getUserDataKeyMapping();
+        if (Utils.isEmpty(userDataKeyMapping)) {
+            return null;
+        }
+        HashMap hashMap = new HashMap();
+        for (String str : map.keySet()) {
+            String str2 = (String) userDataKeyMapping.get(str);
+            if (Utils.isNotEmpty(str2)) {
+                hashMap.put(str2, map.get(str));
+            }
+        }
+        return hashMap;
+    }
+
+    public final Map getLoggedInUserDetails() {
+        return Utils.jsonStringToStringMap(this.persistentStorage.getActiveUser());
+    }
+
+    public final Map getAnonymousUserDetails() {
+        return Utils.jsonStringToStringMap(this.persistentStorage.getAnonymousUserIdMap());
+    }
+
+    public String generateAnonymousUserId() {
+        return "hsft_anon_" + System.currentTimeMillis() + "-" + UUID.randomUUID().toString().replaceAll("-", "").substring(0, 15);
+    }
+
+    public void generateAndSaveAnonymousUserIdIfNeeded() {
+        if (getAnonymousUserDetails().isEmpty()) {
+            HSLogger.d("UsrMngr", "Existing anon user details not found. Generating new anon user ID");
+            JSONObject jSONObject = new JSONObject();
+            try {
+                jSONObject.put("userId", generateAnonymousUserId());
+                this.persistentStorage.storeAnonymousUserIdMap(jSONObject.toString());
+                return;
+            } catch (Exception unused) {
+                HSLogger.d("UsrMngr", "Error in saving the anonymous local user id");
+                return;
+            }
+        }
+        HSLogger.d("UsrMngr", "Existing anon user details found. Not generating new anon user ID");
+    }
+
+    public void setUserLifecycleListener(UserLifecycleListener userLifecycleListener) {
+        this.userLifecycleListenerRef = new WeakReference(userLifecycleListener);
+    }
+
+    public void removeUserLifeCycleListener() {
+        this.userLifecycleListenerRef.clear();
+    }
+
+    public final void startNotificationUpdatesSync() {
+        this.hsThreadingService.getNetworkService().submit(new Runnable() { // from class: com.helpshift.user.UserManager.2
+            @Override // java.lang.Runnable
+            public void run() {
+                UserManager.this.fetchNotificationUpdate.execute();
+                if (UserManager.this.shouldPoll()) {
+                    String currentPushToken = UserManager.this.persistentStorage.getCurrentPushToken();
+                    if (Utils.isEmpty(currentPushToken)) {
+                        UserManager.this.conversationPoller.startPoller();
+                    } else {
+                        UserManager.this.pushTokenManager.registerPushTokenWithBackend(currentPushToken, UserManager.this.getActiveUserDataForNetworkCall(), UserManager.this.new UpdatePushSyncStatus());
+                    }
+                }
+            }
+        });
+    }
+
+    public final boolean shouldSyncPushToken(String str) {
+        String currentPushToken = this.persistentStorage.getCurrentPushToken();
+        return (!Utils.isEmpty(currentPushToken) && currentPushToken.equals(str) && isPushTokenSynced()) ? false : true;
+    }
+
+    public final ValuePair getActiveUserData() {
+        String str = "anon_user_data";
+        JSONObject jSONObject = new JSONObject();
+        String str2 = "";
+        try {
+            String str3 = JsonUtils.EMPTY_JSON;
+            if (!Utils.isEmpty(getLoggedInUserDetails())) {
+                str3 = this.persistentStorage.getString("active_user_data");
+                str = "active_user_data";
+            } else if (Utils.isEmpty(getAnonymousUserDetails())) {
+                str = "";
+            } else {
+                str3 = this.persistentStorage.getString("anon_user_data");
+            }
+            try {
+                if (!Utils.isEmpty(str3)) {
+                    jSONObject = new JSONObject(str3);
+                }
+            } catch (Exception e) {
+                str2 = str;
+                e = e;
+                HSLogger.e("UsrMngr", "Error getting active user in user data", e);
+                str = str2;
+                return new ValuePair(str, jSONObject);
+            }
+        } catch (Exception e2) {
+            e = e2;
+        }
+        return new ValuePair(str, jSONObject);
+    }
+
+    public void setShouldPollFlag(boolean z) {
+        setUserDataValues("should_poll", Boolean.valueOf(z));
+    }
+
+    public void setPollerCursor(long j) {
+        setUserDataValues("cursor", Long.valueOf(j));
+    }
+
+    public void setPollingBaseInterval(int i) {
+        setUserDataValues("base_polling_interval", Integer.valueOf(i));
+    }
+
+    public void setPollingMaxInterval(int i) {
+        setUserDataValues("max_polling_interval", Integer.valueOf(i));
+    }
+
+    public void updateUnreadCountBy(int i) {
+        setUserDataValues("unread_count", Integer.valueOf(getUnreadNotificationCount() + i));
+    }
+
+    public void markAllMessagesAsRead() {
+        setUserDataValues("unread_count", 0);
+    }
+
+    public void setPushTokenSynced(boolean z) {
+        setUserDataValues("push_token_synced", Boolean.valueOf(z));
+    }
+
+    public boolean shouldPoll() {
+        return ((Boolean) getUserDataValue("should_poll", Boolean.FALSE)).booleanValue();
+    }
+
+    public long getPollerCursor() {
+        return Long.valueOf(getUserDataValue("cursor", 0) + "").longValue();
+    }
+
+    public int getPollingMaxInterval() {
+        return ((Integer) getUserDataValue("max_polling_interval", Integer.valueOf(MBridgeCommon.DEFAULT_LOAD_TIMEOUT))).intValue();
+    }
+
+    public int getPollingBaseInterval() {
+        return ((Integer) getUserDataValue("base_polling_interval", 5000)).intValue();
+    }
+
+    public int getUnreadNotificationCount() {
+        return ((Integer) getUserDataValue("unread_count", 0)).intValue();
+    }
+
+    public int getPushUnreadNotificationCount() {
+        return ((Integer) getUserDataValue("push_unread_count", 0)).intValue();
+    }
+
+    public void updatePushUnreadCountBy(int i) {
+        setUserDataValues("push_unread_count", Integer.valueOf(getPushUnreadNotificationCount() + i));
+    }
+
+    public void markAllPushMessagesAsRead() {
+        setUserDataValues("push_unread_count", 0);
+    }
+
+    public boolean isPushTokenSynced() {
+        return ((Boolean) getUserDataValue("push_token_synced", Boolean.FALSE)).booleanValue();
+    }
+
+    public void setShowChatIconInHelpcenter(boolean z) {
+        setUserDataValues("show_chat_icon_in_helpcenter", Boolean.valueOf(z));
+    }
+
+    public boolean shouldShowChatIconInHelpcenter() {
+        return ((Boolean) getUserDataValue("show_chat_icon_in_helpcenter", Boolean.FALSE)).booleanValue();
+    }
+
+    public final Object getUserDataValue(String str, Object obj) {
+        Object opt;
+        ValuePair activeUserData = getActiveUserData();
+        return (Utils.isEmpty((String) activeUserData.first) || (opt = ((JSONObject) activeUserData.second).opt(str)) == null) ? obj : opt;
+    }
+
+    public final void setUserDataValues(String str, Object obj) {
+        ValuePair activeUserData = getActiveUserData();
+        if (Utils.isEmpty((String) activeUserData.first)) {
+            return;
+        }
+        ((JSONObject) activeUserData.second).put(str, obj);
+        this.persistentStorage.putString((String) activeUserData.first, ((JSONObject) activeUserData.second).toString());
+    }
+
+    public class UpdatePushSyncStatus implements ValueListener {
+        public UpdatePushSyncStatus() {
+        }
+
+        @Override // com.helpshift.util.ValueListener
+        public void update(Boolean bool) {
+            UserManager.this.setPushTokenSynced(bool.booleanValue());
+        }
+    }
+}