Qwen-TTS realtime Java SDK

import com.alibaba.dashscope.audio.qwen_tts_realtime.*;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.google.gson.JsonObject;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.AudioSystem;
import java.io.*;
import java.util.Base64;
import java.util.Queue;
import java.util.Scanner;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicBoolean;

public class Main {
  public static QwenTtsRealtimeAudioFormat ttsFormat = QwenTtsRealtimeAudioFormat.PCM_24000HZ_MONO_16BIT;
  // Real-time PCM audio player
  public static class RealtimePcmPlayer {
    private int sampleRate;
    private SourceDataLine line;
    private AudioFormat audioFormat;
    private Thread decoderThread;
    private Thread playerThread;
    private AtomicBoolean stopped = new AtomicBoolean(false);
    private Queue<String> b64AudioBuffer = new ConcurrentLinkedQueue<>();
    private Queue<byte[]> RawAudioBuffer = new ConcurrentLinkedQueue<>();
    private ByteArrayOutputStream totalAudioStream = new ByteArrayOutputStream();


    // Initialize the audio format and audio line.
    public RealtimePcmPlayer(int sampleRate) throws LineUnavailableException {
      this.sampleRate = sampleRate;
      this.audioFormat = new AudioFormat(this.sampleRate, 16, 1, true, false);
      DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
      line = (SourceDataLine) AudioSystem.getLine(info);
      line.open(audioFormat);
      line.start();
      decoderThread = new Thread(new Runnable() {
        @Override
        public void run() {
          while (!stopped.get()) {
            String b64Audio = b64AudioBuffer.poll();
            if (b64Audio != null) {
              byte[] rawAudio = Base64.getDecoder().decode(b64Audio);
              RawAudioBuffer.add(rawAudio);
              // Write audio data to totalAudioStream.
              try {
                totalAudioStream.write(rawAudio);
              } catch (IOException e) {
                throw new RuntimeException(e);
              }
            } else {
              try {
                Thread.sleep(100);
              } catch (InterruptedException e) {
                throw new RuntimeException(e);
              }
            }
          }
        }
      });
      playerThread = new Thread(new Runnable() {
        @Override
        public void run() {
          while (!stopped.get()) {
            byte[] rawAudio = RawAudioBuffer.poll();
            if (rawAudio != null) {
              try {
                playChunk(rawAudio);
              } catch (IOException e) {
                throw new RuntimeException(e);
              } catch (InterruptedException e) {
                throw new RuntimeException(e);
              }
            } else {
              try {
                Thread.sleep(100);
              } catch (InterruptedException e) {
                throw new RuntimeException(e);
              }
            }
          }
        }
      });
      decoderThread.start();
      playerThread.start();
    }

    // Play an audio chunk and block until playback completes.
    private void playChunk(byte[] chunk) throws IOException, InterruptedException {
      if (chunk == null || chunk.length == 0) return;

      int bytesWritten = 0;
      while (bytesWritten < chunk.length) {
        bytesWritten += line.write(chunk, bytesWritten, chunk.length - bytesWritten);
      }
      int audioLength = chunk.length / (this.sampleRate*2/1000);
      // Wait for the buffered audio to finish playing.
      Thread.sleep(audioLength - 10);
    }

    public void write(String b64Audio) {
      b64AudioBuffer.add(b64Audio);
    }

    public void cancel() {
      b64AudioBuffer.clear();
      RawAudioBuffer.clear();
    }

    public void waitForComplete() throws InterruptedException {
      // Wait for all buffered audio data to finish playing.
      while (!b64AudioBuffer.isEmpty() || !RawAudioBuffer.isEmpty()) {
        Thread.sleep(100);
      }
      // Wait for the audio line to drain.
      line.drain();
    }

    public void shutdown() throws InterruptedException {
      stopped.set(true);
      decoderThread.join();
      playerThread.join();
      // Save the complete audio file.
      File file = new File("TotalAudio_"+ttsFormat.getSampleRate()+"."+ttsFormat.getFormat());
      try (FileOutputStream fos = new FileOutputStream(file)) {
        fos.write(totalAudioStream.toByteArray());
      } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
      if (line != null && line.isRunning()) {
        line.drain();
        line.close();
      }
    }
  }

  public static void main(String[] args) throws InterruptedException, LineUnavailableException, FileNotFoundException {
    Scanner scanner = new Scanner(System.in);

    QwenTtsRealtimeParam param = QwenTtsRealtimeParam.builder()
        // To use instruction control, replace the model with qwen3-tts-instruct-flash-realtime.
        .model("qwen3-tts-flash-realtime")
        .url("wss://dashscope-intl.aliyuncs.com/api-ws/v1/realtime")
        .apikey(System.getenv("DASHSCOPE_API_KEY"))
        .build();

    AtomicReference<CountDownLatch> completeLatch = new AtomicReference<>(new CountDownLatch(1));

    // Create a real-time player instance.
    RealtimePcmPlayer audioPlayer = new RealtimePcmPlayer(24000);

    final AtomicReference<QwenTtsRealtime> qwenTtsRef = new AtomicReference<>(null);
    QwenTtsRealtime qwenTtsRealtime = new QwenTtsRealtime(param, new QwenTtsRealtimeCallback() {
      @Override
      public void onOpen() {
        System.out.println("connection opened");
        System.out.println("Enter text and press Enter to send. Enter 'quit' to exit the program.");
      }
      @Override
      public void onEvent(JsonObject message) {
        String type = message.get("type").getAsString();
        switch(type) {
          case "session.created":
            System.out.println("start session: " + message.get("session").getAsJsonObject().get("id").getAsString());
            break;
          case "response.audio.delta":
            String recvAudioB64 = message.get("delta").getAsString();
            byte[] rawAudio = Base64.getDecoder().decode(recvAudioB64);
            // Play audio in real time.
            audioPlayer.write(recvAudioB64);
            break;
          case "response.done":
            System.out.println("response done");
            // Wait for audio playback to complete.
            try {
              audioPlayer.waitForComplete();
            } catch (InterruptedException e) {
              throw new RuntimeException(e);
            }
            // Prepare for the next input.
            completeLatch.get().countDown();
            break;
          case "session.finished":
            System.out.println("session finished");
            if (qwenTtsRef.get() != null) {
              System.out.println("[Metric] response: " + qwenTtsRef.get().getResponseId() +
                  ", first audio delay: " + qwenTtsRef.get().getFirstAudioDelay() + " ms");
            }
            completeLatch.get().countDown();
          default:
            break;
        }
      }
      @Override
      public void onClose(int code, String reason) {
        System.out.println("connection closed code: " + code + ", reason: " + reason);
        try {
          // Wait for playback to complete, then shut down the player.
          audioPlayer.waitForComplete();
          audioPlayer.shutdown();
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    });
    qwenTtsRef.set(qwenTtsRealtime);
    try {
      qwenTtsRealtime.connect();
    } catch (NoApiKeyException e) {
      throw new RuntimeException(e);
    }
    QwenTtsRealtimeConfig config = QwenTtsRealtimeConfig.builder()
        .voice("Cherry")
        .responseFormat(ttsFormat)
        .mode("commit")
        // To use instruction control, uncomment the following lines and replace the model with qwen3-tts-instruct-flash-realtime.
        // .instructions("")
        // .optimizeInstructions(true)
        .build();
    qwenTtsRealtime.updateSession(config);

    // Read user input in a loop.
    while (true) {
      System.out.print("Enter the text to synthesize: ");
      String text = scanner.nextLine();

      // Exit when the user enters 'quit'.
      if ("quit".equalsIgnoreCase(text.trim())) {
        System.out.println("Closing the connection...");
        qwenTtsRealtime.finish();
        completeLatch.get().await();
        break;
      }

      // Skip empty input.
      if (text.trim().isEmpty()) {
        continue;
      }

      // Re-initialize the countdown latch.
      completeLatch.set(new CountDownLatch(1));

      // Send the text.
      qwenTtsRealtime.appendText(text);
      qwenTtsRealtime.commit();

      // Wait for the current synthesis to complete.
      completeLatch.get().await();
    }

    // Clean up resources.
    audioPlayer.waitForComplete();
    audioPlayer.shutdown();
    scanner.close();
    System.exit(0);
  }
}