docs: @SuppressWarnings("unused")
      public void onUserLogin(final Map<String, Object> profile) {
          if (profile == null) return;
  
          try {
              final String currentGUID = getCleverTapID();
              if (currentGUID == null) return;
  
              boolean haveIdentifier = false;
              String cachedGUID = null;
  
              // check for valid identifier keys
              // use the first one we find
              for (String key : profile.keySet()) {
                  Object value = profile.get(key);
                  if (Constants.PROFILE_IDENTIFIER_KEYS.contains(key)) {
                      try {
                          String identifier = value.toString();
                          if (identifier != null && identifier.length() > 0) {
                              haveIdentifier = true;
                              cachedGUID = getGUIDForIdentifier(key, identifier);
                              if (cachedGUID != null) break;
                          }
                      } catch (Throwable t) {
                          // no-op
                      }
                  }
              }
  
              // if no valid identifier provided or there are no identified users on the device; just push on the current profile
              if (!haveIdentifier || isAnonymousDevice()) {
                  getConfigLogger().debug(getAccountId(), "onUserLogin: no identifier provided or device is anonymous, pushing on current user profile");
                  pushProfile(profile);
                  return;
              }
  
              // if identifier maps to current guid, push on current profile
              if (cachedGUID != null && cachedGUID.equals(currentGUID)) {
                  getConfigLogger().debug(getAccountId(), "onUserLogin: " + profile.toString() + " maps to current device id " + currentGUID + " pushing on current profile");
                  pushProfile(profile);
                  return;
              }
  
              // stringify profile to use as dupe blocker
              String profileToString = profile.toString();
  
              // as processing happens async block concurrent onUserLogin requests with the same profile, as our cache is set async
              if (isProcessUserLoginWithIdentifier(profileToString)) {
                  getConfigLogger().debug(getAccountId(), "Already processing onUserLogin for " + profileToString);
                  return;
              }
  
              // create new guid if necessary and reset
              // block any concurrent onUserLogin call for the same profile
              synchronized (processingUserLoginLock) {
                  processingUserLoginIdentifier = profileToString;
              }
  
              getConfigLogger().verbose(getAccountId(), "onUserLogin: queuing reset profile for " + profileToString
                      + " with Cached GUID " + ((cachedGUID != null) ? cachedGUID : "NULL"));
  
  
              final String guid = cachedGUID;
  
              final DeviceInfo _deviceInfo = this.deviceInfo;
  
              postAsyncSafely("resetProfile", new Runnable() {
                  @Override
                  public void run() {
                      try {
                          //set optOut to false on the current user to unregister the device token
                          setCurrentUserOptedOut(false);
                          // unregister the device token on the current user
                          forcePushDeviceToken(false);
  
                          // try and flush and then reset the queues
                          flushQueueSync(context);
                          clearQueues(context);
  
                          // clear out the old data
                          getLocalDataStore().changeUser();
                          inAppFCManager.changeUser(context);
                          activityCount = 1;
                          destroySession();
  
                          // either force restore the cached GUID or generate a new one
                          if (guid != null) {
                              _deviceInfo.forceUpdateDeviceId(guid);
                              notifyUserProfileInitialized(guid);
                          } else {
                              String g = _deviceInfo.forceNewDeviceID();
                              notifyUserProfileInitialized(g);
                          }
                          setCurrentUserOptOutStateFromStorage(); // be sure to call this after the guid is updated
                          forcePushAppLaunchedEvent();
                          pushProfile(profile);
                          forcePushDeviceToken(true);
                          synchronized (processingUserLoginLock) {
                              processingUserLoginIdentifier = null;
                          }
                          resetInbox();
                      } catch (Throwable t) {
                          getConfigLogger().verbose(getAccountId(), "Reset Profile error", t);
                      }
                  }
              });
  
          } catch (Throwable t) {
              getConfigLogger().verbose(getAccountId(), "onUserLogin failed", t);
          }
      }