Add runtime API URL refreshing

Deftu · Deftu · commit 989f6f67a635 · 2025-11-08T16:53:04.000+02:00
diff --git a/src/main/kotlin/org/polyfrost/polyplus/client/PolyPlusClient.kt b/src/main/kotlin/org/polyfrost/polyplus/client/PolyPlusClient.kt
@@ -14,16 +14,14 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 import kotlinx.serialization.json.Json
 import org.apache.logging.log4j.LogManager
-import org.polyfrost.oneconfig.api.event.v1.EventManager
-import org.polyfrost.oneconfig.api.event.v1.events.InitializationEvent
 import org.polyfrost.oneconfig.utils.v1.dsl.addDefaultCommand
 import org.polyfrost.polyplus.PolyPlusConstants
 import org.polyfrost.polyplus.client.cosmetics.CosmeticManager
 import org.polyfrost.polyplus.client.discord.DiscordPresence
+import org.polyfrost.polyplus.client.network.http.PolyAuthorization
 import org.polyfrost.polyplus.client.network.http.PolyCosmetics
 import org.polyfrost.polyplus.client.network.websocket.PolyConnection
 import org.polyfrost.polyplus.client.network.websocket.ServerboundPacket
-import java.util.function.Consumer
 
 object PolyPlusClient {
     private val LOGGER = LogManager.getLogger(PolyPlusConstants.NAME)
@@ -50,22 +48,42 @@ object PolyPlusClient {
     fun initialize() {
         PolyPlusConfig.preload()
         DiscordPresence.initialize()
-        PolyConnection.initialize()
+        PolyConnection.initialize {
+            LOGGER.info("Connected to PolyPlus WebSocket server.")
 
-        SCOPE.launch {
-            val all = PolyCosmetics.getAll()
-                .await()
-                .getOrNull() ?: return@launch
-            CosmeticManager.putAll(all.contents)
-            PolyCosmetics.updateOwned()
-        }
-
-        EventManager.register(InitializationEvent::class.java, Consumer {
+            // Request the local player's active cosmetics
             SCOPE.launch {
                 PolyConnection.sendPacket(ServerboundPacket.GetActiveCosmetics(playerUuid.toString()))
             }
-        })
+        }
 
+        refresh()
         PolyPlusConfig.addDefaultCommand(PolyPlusConstants.ID)
     }
+
+    fun refresh() {
+        LOGGER.info("Refreshing PolyPlus Client...")
+
+        // Synchronously (yet asynchronously) refresh all API data in such a way that we authenticate first,
+        // then give ourselves time to cache cosmetics, then use said known cached cosmetics to update owned cosmetics.
+        SCOPE.launch {
+            // Reset authentication
+            runCatching { PolyAuthorization.reset() }
+
+            // Reset existing caches
+            runCatching { PolyCosmetics.reset() }
+            runCatching { CosmeticManager.reset() }
+
+            // Cache all available cosmetics
+            runCatching {
+                val all = PolyCosmetics.getAll()
+                    .await()
+                    .getOrNull() ?: return@runCatching
+                CosmeticManager.putAll(all.contents)
+            }
+
+            // Update the local player's owned cosmetics
+            runCatching { PolyCosmetics.updateOwned() }
+        }
+    }
 }
diff --git a/src/main/kotlin/org/polyfrost/polyplus/client/PolyPlusConfig.kt b/src/main/kotlin/org/polyfrost/polyplus/client/PolyPlusConfig.kt
@@ -1,5 +1,6 @@
 package org.polyfrost.polyplus.client
 
+import org.apache.logging.log4j.LogManager
 import org.polyfrost.oneconfig.api.config.v1.Config
 import org.polyfrost.oneconfig.api.config.v1.annotations.Dropdown
 import org.polyfrost.oneconfig.api.config.v1.annotations.Switch
@@ -9,20 +10,24 @@ import org.polyfrost.polyplus.client.discord.DiscordPresence
 import org.polyfrost.polyplus.client.network.websocket.PolyConnection
 
 object PolyPlusConfig : Config("${PolyPlusConstants.ID}.json", PolyPlusConstants.NAME, Category.OTHER) {
-    @JvmStatic
-    @Switch(title = "Discord RPC")
+    @Transient
+    private val LOGGER = LogManager.getLogger()
+
+    @JvmStatic @Switch(title = "Discord RPC")
     var isDiscordEnabled = true
 
     @Dropdown(title = "API URL", description = "The URL used for the PolyPlus API. Only change if you know what you're doing.")
     var apiUrl: BackendUrl = BackendUrl.PRODUCTION
 
     init {
         addCallback("isDiscordEnabled") {
-            DiscordPresence.start()
+            DiscordPresence.start() // Ensure that Discord RPC is restarted if the setting was toggled
         }
 
         addCallback("apiUrl") {
-            PolyConnection.reconnect()
+            LOGGER.info("API URL changed to $apiUrl, refreshing API data...")
+            PolyConnection.reconnect() // Reconnect WebSocket under new URL
+            PolyPlusClient.refresh() // Refresh API tokens, cosmetic data, etc.
         }
     }
 }
diff --git a/src/main/kotlin/org/polyfrost/polyplus/client/cosmetics/CosmeticManager.kt b/src/main/kotlin/org/polyfrost/polyplus/client/cosmetics/CosmeticManager.kt
@@ -29,6 +29,10 @@ object CosmeticManager {
         return CACHE[type]?.get(id)?.asResource()
     }
 
+    fun reset() {
+        CACHE.clear()
+    }
+
     suspend fun putAll(cosmetics: List<Cosmetic>) {
         withContext(Dispatchers.IO) {
             hashManager.awaitHashes()
diff --git a/src/main/kotlin/org/polyfrost/polyplus/client/network/http/PolyAuthorization.kt b/src/main/kotlin/org/polyfrost/polyplus/client/network/http/PolyAuthorization.kt
@@ -55,6 +55,13 @@ object PolyAuthorization {
         return lockedJob.await().token
     }
 
+    suspend fun reset() {
+        LOCK.withLock {
+            cachedResponse = null
+            currentJob = null
+        }
+    }
+
     private suspend fun authorize(): AuthResponse {
         val serverId = generateServerId()
         authorizeSessionService(serverId)
diff --git a/src/main/kotlin/org/polyfrost/polyplus/client/network/http/PolyCosmetics.kt b/src/main/kotlin/org/polyfrost/polyplus/client/network/http/PolyCosmetics.kt
@@ -5,7 +5,6 @@ import io.ktor.client.call.body
 import io.ktor.client.request.get
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.async
-import kotlinx.coroutines.launch
 import org.apache.logging.log4j.LogManager
 import org.polyfrost.polyplus.client.PolyPlusClient
 import org.polyfrost.polyplus.client.PolyPlusConfig
@@ -17,31 +16,35 @@ object PolyCosmetics {
     private val LOGGER = LogManager.getLogger()
     private val CACHE = HashMap<UUID, HashMap<String, Int>>()
 
-    fun updateOwned() {
-        PolyPlusClient.SCOPE.launch {
-            val cosmetics = PolyPlusClient.HTTP
-                .getBodyAuthorized<PlayerCosmetics>("${PolyPlusConfig.apiUrl}/cosmetics/player")
-                .onFailure { LOGGER.error("Failed to fetch owned cosmetics", it) }
-                .getOrElse { return@launch LOGGER.warn("Could not fetch owned cosmetics for player $playerUuid") }
-                .owned
-            for (cosmetic in cosmetics) {
-                CACHE[playerUuid] = CACHE.getOrPut(playerUuid) {
-                    HashMap()
-                }.apply {
-                    set(cosmetic.type, cosmetic.id)
-                }
+    suspend fun updateOwned() {
+        val cosmetics = PolyPlusClient.HTTP
+            .getBodyAuthorized<PlayerCosmetics>("${PolyPlusConfig.apiUrl}/cosmetics/player")
+            .onFailure { LOGGER.error("Failed to fetch owned cosmetics", it) }
+            .getOrElse { return LOGGER.warn("Could not fetch owned cosmetics for player $playerUuid") }
+            .owned
+        for (cosmetic in cosmetics) {
+            CACHE[playerUuid] = CACHE.getOrPut(playerUuid) {
+                HashMap()
+            }.apply {
+                set(cosmetic.type, cosmetic.id)
             }
         }
     }
 
     fun getAll(): Deferred<Result<CosmeticList>> = PolyPlusClient.SCOPE.async {
         runCatching {
-            PolyPlusClient.HTTP.get("${PolyPlusConfig.apiUrl}/cosmetics").body<CosmeticList>()
+            PolyPlusClient.HTTP
+                .get("${PolyPlusConfig.apiUrl}/cosmetics")
+                .body<CosmeticList>()
         }.onFailure {
             LOGGER.warn("Failed to fetch all cosmetics: ${it.message}")
         }
     }
 
+    fun reset() {
+        CACHE.clear()
+    }
+
     fun getFor(uuid: UUID): HashMap<String, Int>? {
         return CACHE[uuid]
     }
diff --git a/src/main/kotlin/org/polyfrost/polyplus/client/network/websocket/PolyConnection.kt b/src/main/kotlin/org/polyfrost/polyplus/client/network/websocket/PolyConnection.kt
@@ -16,14 +16,16 @@ import org.polyfrost.polyplus.client.PolyPlusConfig
 object PolyConnection {
     private val LOGGER = LogManager.getLogger()
 
+    private var connectionCallback: (() -> Unit)? = null
     private var job: Job? = null
     private var session: DefaultClientWebSocketSession? = null
     private val _outgoing = Channel<String>(Channel.Factory.UNLIMITED)
 
     val isConnected: Boolean
         get() = session != null
 
-    fun initialize() {
+    fun initialize(callback: (() -> Unit)? = null) {
+        this.connectionCallback = callback
         start() // Just cold start and set up
     }
 
@@ -80,6 +82,7 @@ object PolyConnection {
                         }
                     }
 
+                    connectionCallback?.invoke()
                     for (frame in incoming) {
                         val text = (frame as? Frame.Text)?.readText() ?: continue
                         process(this, text)
diff --git a/versions/1.21.1-fabric/src/main/java/org/polyfrost/polyplus/client/mixin/Mixin_ReplaceCapeTexture.java b/versions/1.21.1-fabric/src/main/java/org/polyfrost/polyplus/client/mixin/Mixin_ReplaceCapeTexture.java
@@ -1,31 +1,38 @@
 package org.polyfrost.polyplus.client.mixin;
 
-import net.minecraft.client.network.AbstractClientPlayerEntity;
-import net.minecraft.client.network.PlayerListEntry;
-import net.minecraft.client.util.SkinTextures;
-import net.minecraft.util.Identifier;
-import org.polyfrost.polyplus.PolyPlus;
+import net.minecraft.client.multiplayer.PlayerInfo;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.resources.PlayerSkin;
+import org.polyfrost.polyplus.client.cosmetics.CosmeticManager;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-@Mixin(AbstractClientPlayerEntity.class)
+@Mixin(AbstractClientPlayer.class)
 public class Mixin_ReplaceCapeTexture {
-    @Shadow private PlayerListEntry playerListEntry;
+    @Shadow private PlayerInfo playerInfo;
 
-    @Inject(method = "getSkinTextures", at = @At("HEAD"), cancellable = true)
-    void polyplus$onGetSkinTextures(CallbackInfoReturnable<SkinTextures> cir) {
-        if (this.playerListEntry == null) return;
-        var oldskinTexures = this.playerListEntry.getSkinTextures();
-        var newSkinTextures = new SkinTextures(
-                oldskinTexures.comp_1626(),
-                oldskinTexures.comp_1911(),
-                Identifier.of(PolyPlus.ID, "moon.png"),
-                oldskinTexures.comp_1628(),
-                oldskinTexures.comp_1629(),
-                oldskinTexures.comp_1630()
+    @Inject(method = "getSkin", at = @At("HEAD"), cancellable = true)
+    void polyplus$onGetSkinTextures(CallbackInfoReturnable<PlayerSkin> cir) {
+        if (this.playerInfo == null) {
+            return;
+        }
+
+        var capeLocation = CosmeticManager.get(this.playerInfo.getProfile().getId(), "cape");
+        if (capeLocation == null) {
+            return;
+        }
+
+        var currentTextures = this.playerInfo.getSkin();
+        var newSkinTextures = new PlayerSkin(
+                currentTextures.texture(),
+                currentTextures.textureUrl(),
+                capeLocation,
+                currentTextures.elytraTexture(),
+                currentTextures.model(),
+                currentTextures.secure()
         );
 
         cir.setReturnValue(newSkinTextures);
