[SkullUtils] - Feature / Bug / Help: Apply Skins without calling the Mojang API about xseries HOT 8 CLOSED

public OfflinePlayer getOfflinePlayer(String name) {
  Preconditions.checkArgument(name != null, "name cannot be null");
  Preconditions.checkArgument(!name.isBlank(), "name cannot be empty");

  // Checks if the player is online to get the online instance
  OfflinePlayer result = this.getPlayerExact(name);
  if (result == null) {
      GameProfile profile = null;
      if (this.getOnlineMode() || SpigotConfig.bungee) {
          // Profile lookup is performed here, obfuscated version of get() method below
          profile = (GameProfile)this.console.ap().a(name).orElse((Object)null);
      }

      if (profile == null) {
          result = this.getOfflinePlayer(new GameProfile(UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8)), name));
          // *** Profiles that are not found are returned with a special UUID, I can check the returned offlineplayer's UUID and if its the same as the one encoded here, i can blacklist it.
         // For reference the this.getOfflinePlayer above makes a new offlineplayer with the same UUID as its profile, but it never actually uses it back later for some reasons...
      } else {
          result = this.getOfflinePlayer(profile);
      }
  } else {
      this.offlinePlayers.remove(((OfflinePlayer)result).getUniqueId());
  }

  return (OfflinePlayer)result;
}

public Optional<GameProfile> get(String s) {
    String s1 = s.toLowerCase(Locale.ROOT);
    UserCache.UserCacheEntry usercache_usercacheentry = (UserCache.UserCacheEntry) this.profilesByName.get(s1);
    boolean flag = false;

    if (usercache_usercacheentry != null && (new Date()).getTime() >= usercache_usercacheentry.expirationDate.getTime()) {
        this.profilesByUUID.remove(usercache_usercacheentry.getProfile().getId());
        this.profilesByName.remove(usercache_usercacheentry.getProfile().getName().toLowerCase(Locale.ROOT));
        flag = true;
        usercache_usercacheentry = null;
    }

    Optional optional;

    if (usercache_usercacheentry != null) {
        usercache_usercacheentry.setLastAccess(this.getNextOperation());
        optional = Optional.of(usercache_usercacheentry.getProfile());
    } else {
        optional = lookupGameProfile(this.profileRepository, s); // Spigot - use correct case for offline players
        // Lookup ^^^^^^^^^^^^^^^^^^^^^^^^^
        if (optional.isPresent()) {
            // @@@ So if for some reasons this player's profile doesn't exist on the server,
            // there is no cache to prevent it from looking it up again?
            this.add((GameProfile) optional.get());
            // Cache ^^^^^^^^^^^^^^^
            flag = false;
        }
    }

    if (flag && !org.spigotmc.SpigotConfig.saveUserCacheOnStopOnly) { // Spigot - skip saving if disabled
        this.save();
    }

    return optional;
}

public void add(GameProfile gameprofile) {
    Calendar calendar = Calendar.getInstance();

    calendar.setTime(new Date());
    calendar.add(2, 1);
    // Cached for a month ^
    Date date = calendar.getTime();
    UserCache.UserCacheEntry usercache_usercacheentry = new UserCache.UserCacheEntry(gameprofile, date);

    this.safeAdd(usercache_usercacheentry);
    if( !org.spigotmc.SpigotConfig.saveUserCacheOnStopOnly ) this.save(); // Spigot - skip saving if disabled
}

private static Optional<GameProfile> lookupGameProfile(GameProfileRepository gameprofilerepository, String s) {
    final AtomicReference<GameProfile> atomicreference = new AtomicReference();
    ProfileLookupCallback profilelookupcallback = new ProfileLookupCallback() {
        public void onProfileLookupSucceeded(GameProfile gameprofile) {
            atomicreference.set(gameprofile);
        }

        public void onProfileLookupFailed(String s1, Exception exception) {
            atomicreference.set(null); // CraftBukkit - decompile error
        }
    };

    gameprofilerepository.findProfilesByNames(new String[]{s}, profilelookupcallback);
    GameProfile gameprofile = (GameProfile) atomicreference.get();

    if (!usesAuthentication() && gameprofile == null) {
        // I'm not sure what usesAuthentication() exactly means but
        // I guess it has something to do with online mode?
        // If that's the case, the report you sent shows it's in online mode 
        // so this block is never getting called anyways.
        UUID uuid = UUIDUtil.createOfflinePlayerUUID(s);

        return Optional.of(new GameProfile(uuid, s));
    } else {
        return Optional.ofNullable(gameprofile);
    }
}