tingwu-sdk-java-realtime

/**
   * Tingwu real-time SDK.
   *
   * @param baseUrl The base URL.
   */
public TingWuRealtime(String baseUrl)

/**
   * Starts a Tingwu real-time session. The correct call order is: first call `call`,
   * then repeatedly call `sendAudioFrame`, and finally call `stop`.
   *
   * @param param The configuration for Tingwu real-time, including audio format,
   *     source language, and target languages.
   * @param callback The result callback.
   */
public void call(
      TingWuRealtimeParam param, TingWuRealtimeCallback callback)

/**
   * Sends one audio frame.
   *
   * @param audioFrame A frame of binary audio.
   */
public void sendAudioFrame(ByteBuffer audioFrame)

/**
   * Stops the Tingwu real-time call session.
   */
public void stop()

/**
 * An abstract class for callbacks that handle real-time transcription events.
 *
 * author songsong.shao
 * date 2025/4/27
 */
public abstract class TingWuRealtimeCallback {

  /**
   * Called when a task starts.
   * @param taskId The task ID.
   */
  public abstract void onStarted(String taskId);

  /**
   * Called when a task stops.
   * @param taskId The task ID.
   */
  public abstract void onStopped(String taskId);

  /**
   * Called when an error occurs.
   *
   * @param errorCode The error code.
   * @param errorMsg The error message.
   */
  public abstract void onError(String errorCode, String errorMsg);

  /**
   * Called when an AI result is available.
   *
   * @param taskId The task ID.
   * @param content The response content as a JsonObject.
   */
  public abstract void onAiResult(String taskId, JsonObject content);

  /**
   * Called when a recognition result is available.
   *
   * @param taskId The task ID.
   * @param content The speech content as a JsonObject.
   */
  public abstract void onRecognizeResult(String taskId, JsonObject content);

  /**
   * Called when the server is ready to listen for speech.
   *
   * @param taskId The task ID.
   * @param dataId The data ID for this task.
   */
  public abstract void onSpeechListen(String taskId, String dataId);

  /** Called when the connection is closed. */
  public abstract void onClosed();
}

{
  "header": {
    "event":"result-generated",
    "task_id": "f2E3zvK*******wp"
  },
  "payload": {
    "output": {
      "action": "recognize-result",
      "transcription": {
        "sentenceId": 0,
        "beginTime": 100,
        "endTime": 2720,
        "sentenceEnd": true,
        "text": "This is a sentence for testing.",
        "words": [
          {
            "beginTime": 100,
            "endTime": 427,
            "text": "This"
          },
          {
            "beginTime": 427,
            "endTime": 755,
            "text": "is a"
          },
          {
            "beginTime": 755,
            "endTime": 1082,
            "text": "sentence"
          },
          {
            "beginTime": 1082,
            "endTime": 1410,
            "text": "used for"
          },
          {
            "beginTime": 1410,
            "endTime": 1737,
            "text": "testing"
          },
          {
            "beginTime": 1737,
            "endTime": 2065,
            "text": "of"
          },
          {
            "beginTime": 2065,
            "endTime": 2392,
            "text": "text"
          },
          {
            "beginTime": 2392,
            "endTime": 2720,
            "text": "."
          }
        ]
      },
      "translations": {
        "sentenceEnd": true,
        "translations": {
          "zh": {
            "sentenceId": 0,
            "beginTime": 100,
            "endTime": 2720,
            "text": "This is a sentence for testing.",
            "lang": "zh",
            "words": [
              {
                "beginTime": 100,
                "endTime": 427,
                "text": "This"
              },
              {
                "beginTime": 427,
                "endTime": 755,
                "text": "is a"
              },
              {
                "beginTime": 755,
                "endTime": 1082,
                "text": "sentence"
              },
              {
                "beginTime": 1082,
                "endTime": 1410,
                "text": "used for"
              },
              {
                "beginTime": 1410,
                "endTime": 1737,
                "text": "testing"
              },
              {
                "beginTime": 1737,
                "endTime": 2065,
                "text": "of"
              },
              {
                "beginTime": 2065,
                "endTime": 2392,
                "text": "text"
              },
              {
                "beginTime": 2392,
                "endTime": 2720,
                "text": "."
              }
            ],
            "sentenceEnd": true
          }
        }
      }
    }
  }
}

package org.alibaba.speech.examples.speech_plus;

import com.alibaba.dashscope.multimodal.tingwu.TingWuRealtime;
import com.alibaba.dashscope.multimodal.tingwu.TingWuRealtimeCallback;
import com.alibaba.dashscope.multimodal.tingwu.TingWuRealtimeParam;
import com.google.gson.JsonObject;
import lombok.extern.slf4j.Slf4j;

import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.concurrent.CountDownLatch;

@Slf4j
public class TingWuRealtimeUsage {

    private static CountDownLatch speechListenLatch = new CountDownLatch(1);
    private static boolean isStopped = false;

    public static TingWuRealtimeCallback tingWuRealtimeCallback = new TingWuRealtimeCallback() {

        @Override
        public void onStarted(String taskId) {
            log.debug("onStarted: {}", taskId);
        }

        @Override
        public void onStopped(String taskId) {
            log.debug("onStopped: {}", taskId);
            isStopped = true;
        }

        @Override
        public void onError(String errorCode, String errorMsg) {
            log.debug("onError: {}, {}", errorCode, errorMsg);
        }

        @Override
        public void onAiResult(String taskId, JsonObject content) {
            log.debug("onAiResult: {}, {}", taskId, content.toString());
        }

        @Override
        public void onRecognizeResult(String taskId, JsonObject content) {
            log.debug("onRecognizeResult: {}, {}", taskId, content.toString());
        }

        @Override
        public void onSpeechListen(String taskId, String dataId) {
            log.debug("onSpeechListen: {}", taskId);
            speechListenLatch.countDown();
        }

        @Override
        public void onClosed() {
            log.debug("onClosed");
        }
    };

    public static void main(String[] args) {
        TingWuRealtimeParam tingWuRealtimeParam = TingWuRealtimeParam.builder()
                .model("tingwu-industrial-instruction")
                .format("pcm")
                .sampleRate(16000)
                .terminology("your-terminology")
                .appId("your-app-id")
                .apiKey("your-api-key")
                .build();

        Path filePath = Paths.get("/path-to-your-file/test.pcm");
        String baseWebsocketApiUrl = "wss://dashscope.aliyuncs.com/api-ws/v1/inference";
        TingWuRealtime tingWuRealtime = new TingWuRealtime(baseWebsocketApiUrl);
        tingWuRealtime.call(tingWuRealtimeParam, tingWuRealtimeCallback);

        try {
            // Wait for the onSpeechListen callback to be triggered, with a timeout of 5 seconds.
            if (!speechListenLatch.await(5, java.util.concurrent.TimeUnit.SECONDS)) {
                log.warn("onSpeechListen callback not received within 5 seconds");
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        log.info("start to send audio....");

        // Send audio.
        try (FileInputStream fis = new FileInputStream(filePath.toFile())) {
            // The chunk size is set to 100 ms for a 16 KHz sample rate.
            byte[] buffer = new byte[3200];
            int bytesRead;
            // Loop to read chunks of the file.
            while ((bytesRead = fis.read(buffer)) != -1 && !isStopped) {
                ByteBuffer byteBuffer;
                if (bytesRead < buffer.length) {
                    byteBuffer = ByteBuffer.wrap(buffer, 0, bytesRead);
                } else {
                    byteBuffer = ByteBuffer.wrap(buffer);
                }
                // Send the ByteBuffer to the Tingwu real-time instance.
                tingWuRealtime.sendAudioFrame(byteBuffer);
                Thread.sleep(100);
                buffer = new byte[3200];
            }
            if (!isStopped) {
                tingWuRealtime.stop();
            }
            Thread.sleep(1000); // Wait for 1 second.
            log.info("end test.");
            tingWuRealtime.getDuplexApi().close(1000, "bye");
        } catch (Exception e) {
            e.printStackTrace();
            tingWuRealtime.getDuplexApi().close(1000, "bye");
        }

        System.exit(0);
    }
}