fix for production

Author: USS-Shenzhou

build.gradle

@@ -251,4 +251,139 @@ tasks.register('stripPreviewMinor', StripPreviewMinorTask) {
 
 tasks.named('classes') {
     finalizedBy tasks.named('stripPreviewMinor')
+}
+
+
+import groovy.json.JsonBuilder
+import groovy.json.JsonSlurper
+
+import java.nio.file.FileSystems
+import java.nio.file.Files
+import java.nio.file.Path
+
+abstract class RemoveWebRTCLibJarjarMetadata extends DefaultTask {
+
+    @InputFile
+    abstract RegularFileProperty getTargetJar()
+
+    @TaskAction
+    void processMetadata() {
+        def jarFile = getTargetJar().get().asFile
+        if (!jarFile.exists()) {
+            return
+        }
+
+        URI uri = URI.create("jar:" + jarFile.toPath().toUri().toString())
+
+        try {
+            FileSystems.newFileSystem(uri, Collections.emptyMap()).withCloseable { fs ->
+                Path metadataPath = fs.getPath("/META-INF/jarjar/metadata.json")
+
+                if (Files.exists(metadataPath)) {
+                    def reader = Files.newBufferedReader(metadataPath)
+                    def json = new JsonSlurper().parse(reader)
+                    reader.close()
+
+                    if (json.jars instanceof List) {
+                        boolean removed = json.jars.removeIf { jarObj ->
+                            String pathStr = jarObj.path?.toString()
+                            return pathStr != null && pathStr.matches(".*webrtc-java-[0-9.]+-.*\\.jar")
+                        }
+
+                        if (removed) {
+                            def writer = Files.newBufferedWriter(metadataPath)
+                            writer.write(new JsonBuilder(json).toPrettyString())
+                            writer.close()
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            project.logger.error("Failed to process jarjar metadata in: " + jarFile.name, e)
+        }
+    }
+}
+
+tasks.register("removeWebRTCLibJarjarMetadata", RemoveWebRTCLibJarjarMetadata) {
+    targetJar.set(tasks.named("jar").flatMap { it.archiveFile })
+}
+
+tasks.named("build") {
+    finalizedBy tasks.named("removeWebRTCLibJarjarMetadata")
+}
+
+import java.nio.file.StandardCopyOption
+import java.util.jar.Manifest
+
+abstract class MakeLibMixinableTask extends DefaultTask {
+
+    @InputFile
+    abstract RegularFileProperty getTargetJar()
+
+    @TaskAction
+    void processJar() {
+        def mainJarFile = getTargetJar().get().asFile
+        if (!mainJarFile.exists()) {
+            return
+        }
+
+        URI mainUri = URI.create("jar:" + mainJarFile.toPath().toUri().toString())
+
+        try {
+            FileSystems.newFileSystem(mainUri, Collections.emptyMap()).withCloseable { mainFs ->
+                Path jarJarDir = mainFs.getPath("/META-INF/jarjar")
+                if (!Files.exists(jarJarDir)) {
+                    return
+                }
+
+                Files.list(jarJarDir).forEach { innerJarPath ->
+                    String fileName = innerJarPath.getFileName().toString()
+
+                    if (fileName.matches("webrtc-java-[0-9.]+\\.jar")) {
+                        Path tempJar = Files.createTempFile("temp-webrtc", ".jar")
+                        Files.copy(innerJarPath, tempJar, StandardCopyOption.REPLACE_EXISTING)
+
+                        boolean needsUpdate = false
+                        URI tempUri = URI.create("jar:" + tempJar.toUri().toString())
+
+                        FileSystems.newFileSystem(tempUri, Collections.emptyMap()).withCloseable { tempFs ->
+                            Path manifestPath = tempFs.getPath("/META-INF/MANIFEST.MF")
+
+                            if (Files.exists(manifestPath)) {
+                                Manifest manifest
+                                Files.newInputStream(manifestPath).withCloseable { is ->
+                                    manifest = new Manifest(is)
+                                }
+
+                                String fmlModType = manifest.getMainAttributes().getValue("FMLModType")
+                                if (fmlModType != "GAMELIBRARY") {
+                                    manifest.getMainAttributes().putValue("FMLModType", "GAMELIBRARY")
+                                    Files.newOutputStream(manifestPath).withCloseable { os ->
+                                        manifest.write(os)
+                                    }
+                                    needsUpdate = true
+                                }
+                            }
+                        }
+
+                        if (needsUpdate) {
+                            Files.copy(tempJar, innerJarPath, StandardCopyOption.REPLACE_EXISTING)
+                        }
+                        Files.deleteIfExists(tempJar)
+                    }
+                }
+            }
+        } catch (Exception e) {
+            project.logger.error("Failed to inject manifest entry in: " + mainJarFile.name, e)
+        }
+    }
+}
+
+tasks.register("makeLibMixinableTask", MakeLibMixinableTask) {
+    targetJar.set(tasks.named("jar").flatMap { it.archiveFile })
+    mustRunAfter tasks.named("removeWebRTCLibJarjarMetadata")
+}
+
+tasks.named("build") {
+    finalizedBy tasks.named("makeLibMixinableTask")
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+distributionUrl=https\://mirrors.aliyun.com/gradle/distributions/v9.2.1/gradle-9.2.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/java/cn/ussshenzhou/channel/audio/server/RelayHandler.java

@@ -1,9 +1,11 @@
 package cn.ussshenzhou.channel.audio.server;
 
 import cn.ussshenzhou.channel.network.TalkPacket2C;
+import cn.ussshenzhou.t88.T88;
 import cn.ussshenzhou.t88.network.NetworkHelper;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import net.minecraft.server.level.ServerPlayer;
+import net.neoforged.neoforge.gametest.GameTestHooks;
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -26,7 +28,7 @@ public static void process(ServerPlayer from, byte[] opusAudio, int sampleRate)
 
     public static void normalTalking(ServerPlayer from, byte[] opusAudio, int sampleRate) {
         from.level().players().stream().filter(to ->
-                        to.getId() != from.getId() &&
+                        (GameTestHooks.isGametestEnabled() || to.getId() != from.getId()) &&
                                 to.position().distanceTo(from.position()) < 64 &&
                                 (!from.isSpectator() || to.isSpectator())
                 )

src/main/java/cn/ussshenzhou/channel/config/ChannelClientConfig.java

@@ -22,8 +22,8 @@ public class ChannelClientConfig implements TConfig {
     public boolean listen = false;
     public Trigger trigger = Trigger.THRESHOLD;
     public Vad voiceDetectThreshold = Vad.LOW;
-    public float triggerThresholdDBFS = -40;
-    public NC noiseCanceling = NC.HIGH;
+    public float triggerThresholdDBFS = -48;
+    public NC noiseCanceling = NC.MID;
     public float aiNoiseCancelingRatio = 0.5f;
     public boolean highPassFilter = true;
     public boolean echoCanceling = false;

src/main/java/cn/ussshenzhou/channel/gui/OutputConfigPanel.java

@@ -14,6 +14,7 @@
 import net.neoforged.bus.api.SubscribeEvent;
 import net.neoforged.fml.common.EventBusSubscriber;
 import net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent;
+import net.neoforged.neoforge.gametest.GameTestHooks;
 import org.joml.Vector2i;
 
 import java.util.*;
@@ -61,7 +62,9 @@ public static class PlayerVolumePanel extends TPanel {
         private static boolean dirty = true;
 
         public PlayerVolumePanel() {
-            //update(Minecraft.getInstance().player.getUUID(), 0);
+            if (GameTestHooks.isGametestEnabled()) {
+                update(Minecraft.getInstance().player.getUUID(), 0);
+            }
             dirty = true;
         }
 

src/main/java/cn/ussshenzhou/channel/mixin/NativeLoaderMixin.java

@@ -1,19 +1,73 @@
 package cn.ussshenzhou.channel.mixin;
 
+import cn.ussshenzhou.channel.audio.client.send.WebRTCHelper;
+import cn.ussshenzhou.channel.util.PlatformUtils;
+import com.mojang.logging.LogUtils;
 import dev.onvoid.webrtc.internal.NativeLoader;
+import net.minecraft.SharedConstants;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
 /**
  * @author USS_Shenzhou
  */
-@Mixin(value = NativeLoader.class, remap = false)
+@Mixin(NativeLoader.class)
 public class NativeLoaderMixin {
 
     @Inject(method = "loadLibrary", at = @At(value = "HEAD"), cancellable = true)
     private static void channelCancelLoad(String libName, CallbackInfo ci) {
+        if (SharedConstants.IS_RUNNING_WITH_JDWP) {
+            LogUtils.getLogger().warn("We are in a dev env now. Native things may work differently.");
+            return;
+        }
+        loadNativeInternal(PlatformUtils.getOS(), PlatformUtils.getLibSuffix());
         ci.cancel();
     }
+
+    @Unique
+    private static void loadNativeInternal(String platform, String fileSuffix) {
+        var jarJarPath = "/META-INF/jarjar/webrtc-java-0.14.0-" + platform + ".jar";
+        var libName = "webrtc-java-" + platform + fileSuffix;
+        LogUtils.getLogger().info("Loading " + libName + " from " + jarJarPath);
+        try (var resourceStream = WebRTCHelper.class.getResourceAsStream(jarJarPath)) {
+            if (resourceStream == null) {
+                throw new RuntimeException("Mod Jar is not complete.");
+            }
+            try (var zipStream = new ZipInputStream(resourceStream)) {
+                ZipEntry entry;
+                boolean found = false;
+                while ((entry = zipStream.getNextEntry()) != null) {
+                    found = findAndLoad(fileSuffix, entry, libName, zipStream, found);
+                    zipStream.closeEntry();
+                }
+                if (!found) {
+                    throw new RuntimeException("Failed to extract and load WebRTC. Something went wrong.");
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to load WebRTC lib.", e);
+        }
+        LogUtils.getLogger().info("Successfully loaded WebRTC lib.");
+    }
+
+    @Unique
+    private static boolean findAndLoad(String fileSuffix, ZipEntry entry, String libName, ZipInputStream zipStream, boolean found) throws IOException {
+        if (entry.getName().equals(libName)) {
+            var tempLib = Files.createTempFile("Channel_WebRTC_", fileSuffix);
+            tempLib.toFile().deleteOnExit();
+            Files.copy(zipStream, tempLib, StandardCopyOption.REPLACE_EXISTING);
+            System.load(tempLib.toAbsolutePath().toString());
+            found = true;
+        }
+        return found;
+    }
 }

src/main/java/cn/ussshenzhou/channel/util/PlatformUtils.java

@@ -0,0 +1,48 @@
+package cn.ussshenzhou.channel.util;
+
+/**
+ * @author USS_Shenzhou
+ */
+public class PlatformUtils {
+
+    public static String getOS() {
+        String osName = System.getProperty("os.name").toLowerCase(java.util.Locale.ROOT);
+        String osArch = System.getProperty("os.arch").toLowerCase(java.util.Locale.ROOT);
+
+        String os;
+        if (osName.contains("win")) {
+            os = "windows";
+        } else if (osName.contains("mac")) {
+            os = "macos";
+        } else if (osName.contains("nix") || osName.contains("nux") || osName.contains("aix")) {
+            os = "linux";
+        } else {
+            throw new UnsupportedOperationException("Unsupported operating system: " + osName);
+        }
+
+        String arch;
+        if ("amd64".equals(osArch) || "x86_64".equals(osArch)) {
+            arch = "x86_64";
+        } else if ("aarch64".equals(osArch)) {
+            arch = "aarch64";
+        } else {
+            throw new UnsupportedOperationException("Unsupported architecture: " + osArch);
+        }
+
+        return os + "-" + arch;
+    }
+
+    public static String getLibSuffix() {
+        String osName = System.getProperty("os.name").toLowerCase(java.util.Locale.ROOT);
+
+        if (osName.contains("win")) {
+            return ".dll";
+        } else if (osName.contains("mac")) {
+            return ".dylib";
+        } else if (osName.contains("nix") || osName.contains("nux") || osName.contains("aix")) {
+            return ".so";
+        } else {
+            throw new UnsupportedOperationException("Unsupported operating system: " + osName);
+        }
+    }
+}