Gummy实时语音识别、翻译Java API_大模型服务平台百炼(Model Studio)-阿里云帮助中心

前提条件

已开通服务并获得API-KEY：获取API Key。建议您配置API Key到环境变量，从而避免在代码里显示配置API Key，降低泄漏风险。
已安装最新版DashScope SDK：安装SDK。

模型列表

模型名

模型简介

gummy-realtime-v1

Gummy实时语音识别、翻译模型。默认进行标点符号预测和逆文本正则化（INT，Inverse Text Normalization）。支持定制热词。

模型使用VAD（Voice Activity Detection）断句。

快速开始

TranslationRecognizerRealtime类提供了语音识别/翻译的关键接口，支持以下几种调用方式：

流式调用：可直接对音频流进行识别/翻译，并实时输出结果。音频流可以来自外部设备（如麦克风）或从本地文件读取。适合需要即时反馈的场景。
同步调用：针对本地文件进行识别/翻译，并一次性返回完整的处理结果。适合处理录制好的音频。

流式调用：基于回调

通过实现回调接口，实时流式输出识别结果。

启动流式语音识别/翻译
实例化TranslationRecognizerRealtime类，调用call方法绑定请求参数和回调接口（ResultCallback）并启动流式语音识别/翻译。
流式传输
循环调用TranslationRecognizerRealtime类的sendAudioFrame方法，将从本地文件或设备（如麦克风）读取的二进制音频流分段发送至服务端。
在发送音频数据的过程中，服务端会通过回调接口（ResultCallback）的onEvent方法，将识别结果实时返回给客户端。
建议每次发送的音频时长约为100毫秒，数据大小保持在1KB至16KB之间。
结束处理
调用TranslationRecognizerRealtime类的stop方法结束语音识别/翻译。
该方法会阻塞当前线程，直到回调接口（ResultCallback）的onComplete或者onError回调触发后才会释放线程阻塞。

点击查看完整示例

识别传入麦克风的语音

识别本地语音文件

import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerParam;
import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerRealtime;
import com.alibaba.dashscope.audio.asr.translation.results.TranslationRecognizerResult;
import com.alibaba.dashscope.common.ResultCallback;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.TargetDataLine;

import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(new RealtimeRecognitionTask());
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.MINUTES);
        System.exit(0);
    }
}

class RealtimeRecognitionTask implements Runnable {
    @Override
    public void run() {
        String targetLanguage = "en";
        // 初始化请求参数
        TranslationRecognizerParam param =
                TranslationRecognizerParam.builder()
                        // 若没有将API Key配置到环境变量中，需将your-api-key替换为自己的API Key
                        // .apiKey("your-api-key")
                        .model("gummy-realtime-v1") // 设置模型名
                        .format("pcm") // 设置待识别音频格式，支持的音频格式：pcm、wav、mp3、opus、speex、aac、amr
                        .sampleRate(16000) // 设置待识别音频采样率（单位Hz）。支持16000Hz及以上采样率。
                        .transcriptionEnabled(true) // 设置是否开启实时识别
                        .sourceLanguage("auto") // 设置源语言（待识别/翻译语言）代码
                        .translationEnabled(true) // 设置是否开启实时翻译
                        .translationLanguages(new String[] {targetLanguage}) // 设置翻译目标语言
                        .build();

        // 初始化回调接口
        ResultCallback<TranslationRecognizerResult> callback =
                new ResultCallback<TranslationRecognizerResult>() {
                    @Override
                    public void onEvent(TranslationRecognizerResult result) {
                        System.out.println("RequestId: " + result.getRequestId());
                        // 打印最终结果
                        if (result.getTranscriptionResult() != null) {
                            System.out.println("Transcription Result:"+result);
                            if (result.isSentenceEnd()) {
                                System.out.println("\tFix:" + result.getTranscriptionResult().getText());
                                System.out.println("\tStash:" + result.getTranscriptionResult().getStash());
                            } else {
                                System.out.println("\tTemp Result:" + result.getTranscriptionResult().getText());
                            }
                        }
                        if (result.getTranslationResult() != null) {
                            System.out.println("English Translation Result:");
                            if (result.isSentenceEnd()) {
                                System.out.println("\tFix:" + result.getTranslationResult().getTranslation(targetLanguage).getText());
                                System.out.println("\tStash:" + result.getTranslationResult().getTranslation(targetLanguage).getStash());
                            } else {
                                System.out.println("\tTemp Result:" + result.getTranslationResult().getTranslation(targetLanguage).getText());
                            }
                        }
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("Translation complete");
                    }

                    @Override
                    public void onError(Exception e) {
                        e.printStackTrace();
                        System.out.println("TranslationCallback error: " + e.getMessage());
                    }
                };

        // 初始化流式识别服务
        TranslationRecognizerRealtime translator = new TranslationRecognizerRealtime();
        // 启动流式语音识别/翻译，绑定请求参数和回调接口
        translator.call(param, callback);

        try {
            // 创建音频格式
            AudioFormat audioFormat = new AudioFormat(16000, 16, 1, true, false);
            // 根据格式匹配默认录音设备
            TargetDataLine targetDataLine =
                    AudioSystem.getTargetDataLine(audioFormat);
            targetDataLine.open(audioFormat);
            // 开始录音
            targetDataLine.start();
            System.out.println("请您通过麦克风讲话体验实时语音识别和翻译功能");
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            long start = System.currentTimeMillis();
            // 录音50s并进行实时识别
            while (System.currentTimeMillis() - start < 50000) {
                int read = targetDataLine.read(buffer.array(), 0, buffer.capacity());
                if (read > 0) {
                    buffer.limit(read);
                    // 将录音音频数据发送给流式识别服务
                    translator.sendAudioFrame(buffer);
                    buffer = ByteBuffer.allocate(1024);
                    // 录音速率有限，防止cpu占用过高，休眠一小会儿
                    Thread.sleep(20);
                }
            }
            // 通知结束
            translator.stop();
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(
                "[Metric] requestId: "
                        + translator.getLastRequestId()
                        + ", first package delay ms: "
                        + translator.getFirstPackageDelay()
                        + ", last package delay ms: "
                        + translator.getLastPackageDelay());
    }
}

示例中用到的音频为：hello_world.wav。

import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerParam;
import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerRealtime;
import com.alibaba.dashscope.audio.asr.translation.results.TranslationRecognizerResult;
import com.alibaba.dashscope.common.ResultCallback;
import com.alibaba.dashscope.exception.NoApiKeyException;

import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class RealtimeTranslateTask implements Runnable {
    private Path filepath;

    public RealtimeTranslateTask(Path filepath) {
        this.filepath = filepath;
    }

    @Override
    public void run() {
        String targetLanguage = "en";
        // Create translation params
        // you can customize the translation parameters, like model, format,
        // sample_rate for more information, please refer to
        // https://help.aliyun.com/document_detail/2712536.html
        TranslationRecognizerParam param =
                TranslationRecognizerParam.builder()
                        // 若没有将API Key配置到环境变量中，需将your-api-key替换为自己的API Key
                        // .apiKey("your-api-key")
                        .model("gummy-realtime-v1")
                        .format("pcm") // 'pcm'、'wav'、'mp3'、'opus'、'speex'、'aac'、'amr', you
                        // can check the supported formats in the document
                        .sampleRate(16000)
                        .transcriptionEnabled(true)
                        .sourceLanguage("auto")
                        .translationEnabled(true)
                        .translationLanguages(new String[] {targetLanguage})
                        .build();
        TranslationRecognizerRealtime translator = new TranslationRecognizerRealtime();
        CountDownLatch latch = new CountDownLatch(1);

        String threadName = Thread.currentThread().getName();

        ResultCallback<TranslationRecognizerResult> callback =
                new ResultCallback<TranslationRecognizerResult>() {
                    @Override
                    public void onEvent(TranslationRecognizerResult result) {
                        System.out.println("RequestId: " + result.getRequestId());
                        // 打印最终结果
                        if (result.getTranscriptionResult() != null) {
                            System.out.println("Transcription Result:"+result);
                            if (result.isSentenceEnd()) {
                                System.out.println("\tFix:" + result.getTranscriptionResult().getText());
                                System.out.println("\tStash:" + result.getTranscriptionResult().getStash());
                            } else {
                                System.out.println("\tTemp Result:" + result.getTranscriptionResult().getText());
                            }
                        }
                        if (result.getTranslationResult() != null) {
                            System.out.println("English Translation Result:");
                            if (result.isSentenceEnd()) {
                                System.out.println("\tFix:" + result.getTranslationResult().getTranslation(targetLanguage).getText());
                                System.out.println("\tStash:" + result.getTranslationResult().getTranslation(targetLanguage).getStash());
                            } else {
                                System.out.println("\tTemp Result:" + result.getTranslationResult().getTranslation(targetLanguage).getText());
                            }
                        }
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("[" + threadName + "] Translation complete");
                        latch.countDown();
                    }

                    @Override
                    public void onError(Exception e) {
                        e.printStackTrace();
                        System.out.println("[" + threadName + "] TranslationCallback error: " + e.getMessage());
                    }
                };
        // set param & callback
        translator.call(param, callback);
        // Please replace the path with your audio file path
        System.out.println("[" + threadName + "] Input file_path is: " + this.filepath);
        // Read file and send audio by chunks
        try (FileInputStream fis = new FileInputStream(this.filepath.toFile())) {
            // chunk size set to 1 seconds for 16KHz sample rate
            byte[] buffer = new byte[3200];
            int bytesRead;
            // Loop to read chunks of the file
            while ((bytesRead = fis.read(buffer)) != -1) {
                ByteBuffer byteBuffer;
                // Handle the last chunk which might be smaller than the buffer size
                System.out.println("[" + threadName + "] bytesRead: " + bytesRead);
                if (bytesRead < buffer.length) {
                    byteBuffer = ByteBuffer.wrap(buffer, 0, bytesRead);
                } else {
                    byteBuffer = ByteBuffer.wrap(buffer);
                }
                // Send the ByteBuffer to the translation instance
                translator.sendAudioFrame(byteBuffer);
                buffer = new byte[3200];
                Thread.sleep(100);
            }
            System.out.println(LocalDateTime.now());
        } catch (Exception e) {
            e.printStackTrace();
        }

        translator.stop();
        // wait for the translation to complete
        try {
            latch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

public class Main {
    public static void main(String[] args)
            throws NoApiKeyException, InterruptedException {

        String currentDir = System.getProperty("user.dir");
        // Please replace the path with your audio source
        Path[] filePaths = {
                Paths.get(currentDir, "hello_world.wav"),
//                Paths.get(currentDir, "hello_world_male_16k_16bit_mono.wav"),
        };
        // Use ThreadPool to run recognition tasks
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (Path filepath:filePaths) {
            executorService.submit(new RealtimeTranslateTask(filepath));
        }
        executorService.shutdown();
        // wait for all tasks to complete
        executorService.awaitTermination(1, TimeUnit.MINUTES);
        System.exit(0);
    }
}

流式调用：基于Flowable

通过工作流（Flowable）的方式流式输出实时识别结果。

Flowable 是一个用于工作流和业务流程管理的开源框架，它基于 Apache 2.0 许可证发布。关于Flowable的使用，请参见Flowable API详情。

点击查看完整示例

直接调用TranslationRecognizerRealtime类的streamCall方法启动识别。

该方法返回一个Flowable<TranslationRecognizerResult>实例，您可通过调用Flowable的blockingForEach或subscribe等方法处理实时识别/翻译结果（TranslationRecognizerResult）。

import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerParam;
import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerRealtime;
import com.alibaba.dashscope.exception.NoApiKeyException;
import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.TargetDataLine;
import java.nio.ByteBuffer;

public class Main {
    public static void main(String[] args) throws NoApiKeyException {
        // 创建一个Flowable<ByteBuffer>
        String targetLanguage = "en";
        Flowable<ByteBuffer> audioSource =
                Flowable.create(
                        emitter -> {
                            new Thread(
                                    () -> {
                                        try {
                                            // 创建音频格式
                                            AudioFormat audioFormat = new AudioFormat(16000, 16, 1, true, false);
                                            // 根据格式匹配默认录音设备
                                            TargetDataLine targetDataLine =
                                                    AudioSystem.getTargetDataLine(audioFormat);
                                            targetDataLine.open(audioFormat);
                                            // 开始录音
                                            targetDataLine.start();
                                            System.out.println("请您通过麦克风讲话体验实时语音识别和翻译功能");
                                            ByteBuffer buffer = ByteBuffer.allocate(1024);
                                            long start = System.currentTimeMillis();
                                            // 录音50s并进行实时识别
                                            while (System.currentTimeMillis() - start < 50000) {
                                                int read = targetDataLine.read(buffer.array(), 0, buffer.capacity());
                                                if (read > 0) {
                                                    buffer.limit(read);
                                                    // 将录音音频数据发送给流式识别服务
                                                    emitter.onNext(buffer);
                                                    buffer = ByteBuffer.allocate(1024);
                                                    // 录音速率有限，防止cpu占用过高，休眠一小会儿
                                                    Thread.sleep(20);
                                                }
                                            }
                                            // 通知结束
                                            emitter.onComplete();
                                        } catch (Exception e) {
                                            emitter.onError(e);
                                        }
                                    })
                                    .start();
                        },
                        BackpressureStrategy.BUFFER);

        // 创建Recognizer
        TranslationRecognizerRealtime translator = new TranslationRecognizerRealtime();
        // 创建RecognitionParam，audioFrames参数中传入上面创建的Flowable<ByteBuffer>
        TranslationRecognizerParam param =
                TranslationRecognizerParam.builder()
                        // 若没有将API Key配置到环境变量中，需将your-api-key替换为自己的API Key
                        // .apiKey("your-api-key")
                        .model("gummy-realtime-v1")
                        .format("pcm") // 'pcm'、'wav'、'mp3'、'opus'、'speex'、'aac'、'amr', you
                        // can check the supported formats in the document
                        .sampleRate(16000)
                        .transcriptionEnabled(true)
                        .sourceLanguage("auto")
                        .translationEnabled(true)
                        .translationLanguages(new String[] {targetLanguage})
                        .build();

        // 流式调用接口
        translator
                .streamCall(param, audioSource)
                // 调用Flowable的blockingForEachc处理结果
                .blockingForEach(
                        result -> {
                            if (result.getTranscriptionResult() == null) {
                                return;
                            }
                            try {
                                System.out.println("RequestId: " + result.getRequestId());
                                // 打印最终结果
                                if (result.getTranscriptionResult() != null) {
                                    System.out.println("Transcription Result:");
                                    if (result.isSentenceEnd()) {
                                        System.out.println("\tFix:" + result.getTranscriptionResult().getText());
                                        System.out.println("\tStash:" + result.getTranscriptionResult().getStash());
                                    } else {
                                        System.out.println("\tTemp Result:" + result.getTranscriptionResult().getText());
                                    }
                                }
                                if (result.getTranslationResult() != null) {
                                    System.out.println("English Translation Result:");
                                    if (result.isSentenceEnd()) {
                                        System.out.println("\tFix:" + result.getTranslationResult().getTranslation(targetLanguage).getText());
                                        System.out.println("\tStash:" + result.getTranslationResult().getTranslation(targetLanguage).getStash());
                                    } else {
                                        System.out.println("\tTemp Result:" + result.getTranslationResult().getTranslation(targetLanguage).getText());
                                    }
                                }
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        });
        System.exit(0);
    }
}

同步调用

通过传入本地文件路径，以同步阻塞方式获取识别或翻译结果。

实例化TranslationRecognizerRealtime类，调用call方法绑定请求参数和待识别文件，进行识别并最终获取同步调用结果（TranslationRecognizerResultPack）。

点击查看完整示例

示例中用到的音频为：hello_world.wav。

import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerParam;
import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerRealtime;
import com.alibaba.dashscope.audio.asr.translation.results.TranscriptionResult;
import com.alibaba.dashscope.audio.asr.translation.results.TranslationRecognizerResultPack;
import com.alibaba.dashscope.audio.asr.translation.results.TranslationResult;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        String targetLanguage = "en";
        // 创建Recognition实例
        TranslationRecognizerRealtime translator = new TranslationRecognizerRealtime();
        // 创建RecognitionParam，请在实际使用中替换真实apiKey
        TranslationRecognizerParam param =
                TranslationRecognizerParam.builder()
                        // 若没有将API Key配置到环境变量中，需将下面这行代码注释放开，并将your-api-key替换为自己的API Key
                        // .apiKey("your-api-key")
                        .model("gummy-realtime-v1")
                        .format("wav") // 'pcm'、'wav'、'mp3'、'opus'、'speex'、'aac'、'amr', you
                        // can check the supported formats in the document
                        .sampleRate(16000)
                        .transcriptionEnabled(true)
                        .sourceLanguage("auto")
                        .translationEnabled(true)
                        .translationLanguages(new String[] {targetLanguage})
                        .build();
        // 直接将结果保存到script.txt中
        TranslationRecognizerResultPack result = translator.call(param, new File("hello_world.wav"));
        if (result.getError() != null) {
            System.out.println("error: " + result.getError());
            throw new RuntimeException(result.getError());
        } else {
            System.out.println("RequestId: " + result.getRequestId());
            System.out.println("Transcription Results:");
            ArrayList<TranscriptionResult> transcriptionResults = result.getTranscriptionResultList();
            for (int i = 0; i < transcriptionResults.size(); i++) {
                System.out.println(transcriptionResults.get(i).getText());
            }

            System.out.println("English Translation Results:");
            ArrayList<TranslationResult> translationResultList = result.getTranslationResultList();
            for (int i = 0; i < translationResultList.size(); i++) {
                System.out.println(translationResultList.get(i).getTranslation(targetLanguage).getText());
            }
        }
        System.exit(0);
    }
}

请求参数

通过TranslationRecognizerParam的链式方法配置模型、采样率、音频格式等参数。配置完成的参数对象传入TranslationRecognizerRealtime类的call/streamCall方法中使用。

点击查看示例

TranslationRecognizerParam param =
        TranslationRecognizerParam.builder()
                .model("gummy-realtime-v1")
                .format("pcm")
                .sampleRate(16000)
                .transcriptionEnabled(true)
                .translationEnabled(true)
                .translationLanguages(new String[] {"en"})
                .build();

参数	类型	默认值	是否必须	说明

参数	类型	默认值	是否必须	说明
model	String	-	是	设置实时语音识别的模型。如需了解当前支持的模型，请参见模型列表。
sampleRate	Integer	-	是	设置待识别音频采样率（单位Hz）。支持16000Hz及以上采样率。
format	String	-	是	设置待识别音频格式。支持的音频格式：pcm、wav、mp3、opus、speex、aac、amr。
vocabularyId	String	-	否	设置热词ID，若未设置则不生效。在本次语音识别中，将应用与该热词ID对应的热词信息。具体使用方法请参见定制热词。
sourceLanguage	String	auto	否	设置源语言（待识别/翻译语言）代码。如果无法提前确定语种，可不设置，默认为`auto`。目前支持的语言代码： zh: 中文 en: 英文 ja: 日语 yue: 粤语 ko: 韩语 de: 德语 fr: 法语 ru: 俄语 it: 意大利语 es: 西班牙语
transcriptionEnabled	boolean	true	否	设置是否启用识别功能。模型支持单独开启识别或翻译功能，也可同时启用两种功能，但至少需要开启其中一种能力。
translationEnabled	boolean	false	否	设置是否启用翻译功能。要正常输出翻译结果，需配置`translationLanguages`参数。模型支持单独开启识别或翻译功能，也可同时启用两种功能，但至少需要开启其中一种能力。
translationLanguages	String[]	-	否	设置翻译目标语言代码。目标语言的代码与`sourceLanguage`参数一致。目前支持的翻译包括：中->英，中->日，中->韩，英->中，英->日，英->韩，（日、韩、粤、德、法、俄、意、西）->（中、英）。重要目前暂不支持同时翻译为多种语言，请仅设置一个目标语言以完成翻译。
apiKey	String	-	否	设置用户API Key。

关键接口

`TranslationRecognizerRealtime`类

TranslationRecognizerRealtime通过“import com.alibaba.dashscope.audio.asr.translation.TranslationRecognizerRealtime;”方式引入，提供语音识别/翻译的关键接口。

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public void call(TranslationRecognizerParam param, final ResultCallback<TranslationRecognizerResult> callback)`	`param`：请求参数 `callback`：回调接口（ResultCallback）	无	启动流式语音识别/翻译。 `call`、`sendAudioFrame`和`stop`方法在流式语音识别/翻译时配合使用。适合需要即时反馈的场景。详细的调用流程和参考示例请参见流式调用：基于回调。
`public void sendAudioFrame(ByteBuffer audioFrame)`	`audioFrame`：二进制音频流，为`ByteBuffer`类型	无	推送音频，每次推送的音频流大小应适中，建议每包音频时长控制在100ms左右，大小保持在1KB~16KB之间。识别/翻译结果并通过回调接口（ResultCallback）的`onEvent`方法实时获取。 `call`、`sendAudioFrame`和`stop`方法在流式语音识别/翻译时配合使用。适合需要即时反馈的场景。详细的调用流程和参考示例请参见流式调用：基于回调。
`public void stop()`	无	无	结束流式语音识别/翻译。该方法会阻塞当前线程，直至回调接口（ResultCallback）的`onComplete`或`onError`方法被调用后，才会解除对当前线程的阻塞。 `call`、`sendAudioFrame`和`stop`方法在流式语音识别/翻译时配合使用。适合需要即时反馈的场景。详细的调用流程和参考示例请参见流式调用：基于回调。
`public TranslationRecognizerResultPack call(TranslationRecognizerParam param, File file)`	`param`：请求参数 `file`：文件	同步调用结果（TranslationRecognizerResultPack）	基于本地文件的同步调用，该方法最终返回识别/翻译结果。要求待识别文件具有可读权限。适合处理录制好的音频。详细的调用流程和参考示例请参见同步调用。
`public Flowable<TranslationRecognizerResult> streamCall(TranslationRecognizerParam param, Flowable<ByteBuffer> audioFrame)`	`param`：请求参数 `audioFrame`：`Flowable<ByteBuffer>`实例	`Flowable<TranslationRecognizerResult>`	基于`Flowable`的流式实时识别。详细的调用流程和参考示例请参见流式调用：基于Flowable。

回调接口（`ResultCallback`）

ResultCallback通过“import com.alibaba.dashscope.common.ResultCallback;”方式引入。

使用流式调用：基于回调调用模式时通过回调接口ResultCallback获取识别结果。

点击查看示例

ResultCallback<TranslationRecognizerResult> callback = new ResultCallback<TranslationRecognizerResult>() {
    @Override
    public void onEvent(TranslationRecognizerResult result) {
        System.out.println("RequestId为：" + result.getRequestId());
        // 在此实现处理语音识别结果的逻辑
    }

    @Override
    public void onComplete() {
        System.out.println("任务完成");
    }

    @Override
    public void onError(Exception e) {
        System.out.println("任务失败：" + e.getMessage());
    }
};

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public void onEvent(TranslationRecognizerResult result)`	`result`：实时识别/翻译结果（TranslationRecognizerResult）	无	当服务有回复时会被回调。
`public void onComplete()`	无	无	任务完成后该接口被回调。
`public void onError(Exception e)`	`e`：异常信息	无	发生异常时该接口被回调。

响应结果

实时识别/翻译结果（`TranslationRecognizerResult`）

TranslationRecognizerResult封装了识别结果（TranscriptionResult）和翻译结果（TranslationResult）。

由于语言间的词汇差异，识别和翻译的中间结果可能不会同时返回，因此某些情况下结果可能仅包含识别或翻译的部分。识别与翻译的进度会在isSentenceEnd为true时同步完成。

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public TranscriptionResult getTranscriptionResult()`	无	识别结果（TranscriptionResult）	获取实时识别结果。
`public TranslationResult getTranslationResult()`	无	翻译结果（TranslationResult）	获取实时翻译结果。

识别结果（`TranscriptionResult`）

TranscriptionResult封装了识别结果，包含时间戳、文本信息以及文本是否构成完整句子等信息。

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public Long getSentenceId()`	无	句子ID	返回句子ID。
`public Long getBeginTime()`	无	句子开始时间，单位为ms	返回句子开始时间。
`public Long getEndTime()`	无	句子结束时间，单位为ms	返回句子结束时间。
`public String getText()`	无	识别文本	返回识别文本。
`public List<Word> getWords()`	无	字时间戳信息（Word）的List集合	返回字时间戳信息。
`public Stash getStash()`	无	后一句未断句识别结果（Stash）	语义断句发生时，返回后一句未断句的识别结果。
`public boolean isSentenceEnd()`	无	true：当前文本构成完整句子，识别结果为最终版本 false：当前文本尚未构成完整句子，识别结果可能会变化	当前文本是否构成完整的句子。

翻译结果（`TranslationResult`）

TranslationResult封装了翻译结果，包含请求参数transcriptionTargetLanguages对应的所有语种的翻译结果。

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public List<String> getLanguageList()`	无	翻译结果中的所有语种列表	返回翻译结果中的所有语种列表。
`public Translation getTranslation(String language)`	`language`：语种	某语种对应的翻译结果（Translation）	返回某语种对应的翻译结果。
`public boolean isSentenceEnd()`	无	true：当前文本构成完整句子，翻译结果为最终版本 false：当前文本尚未构成完整句子，翻译结果可能会变化	当前文本是否构成完整的句子。

某语种对应的翻译结果（`Translation`）

TranscriptionResult封装了某种语言的翻译结果，包含时间戳、文本信息以及文本是否构成完整句子等信息。

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public Long getSentenceId()`	无	句子ID	返回句子ID。
`public String getLanguage()`	无	翻译语种	返回翻译语种。
`public Long getBeginTime()`	无	句子开始时间，单位为ms	返回句子开始时间。
`public Long getEndTime()`	无	句子结束时间，单位为ms	返回句子结束时间。
`public String getText()`	无	识别文本	返回识别文本。
`public List<Word> getWords()`	无	字时间戳信息（Word）的List集合	返回字时间戳信息。
`public Stash getStash()`	无	后一句未断句识别结果（Stash）	语义断句发生时，返回后一句未断句的识别结果。
`public boolean isSentenceEnd()`	无	true：当前文本构成完整句子，翻译结果为最终版本 false：当前文本尚未构成完整句子，翻译结果可能会变化	当前文本是否构成完整的句子。

后一句未断句识别结果（`Stash`）

在当前识别或翻译过程中，若部分文本已成句，则成句部分会包含在识别结果（TranscriptionResult）或某语种对应的翻译结果（Translation）中，而未成句的剩余内容会存储在Stash中。成句结果与Stash共同构成当前的完整结果。

以下示例展示了一次实时识别中TranscriptionResult和Stash的变化过程：

No	`TranscriptionResult.text`	`TranscriptionResult.stash.text`

No	`TranscriptionResult.text`	`TranscriptionResult.stash.text`
1	早	-
2	早上	-
3	早上好	-
4	早上好，今天	-
5	早上好。	今天的
6	今天的天气	-
7	今天的天气怎么样？	-

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public Long getSentenceId()`	无	句子ID	返回句子ID。
`public Long getBeginTime()`	无	句子开始时间，单位为ms	返回句子开始时间。
`public Long getEndTime()`	无	句子结束时间，单位为ms	返回句子结束时间。
`public String getText()`	无	识别文本	返回识别文本。
`public List<Word> getWords()`	无	字时间戳信息（Word）的List集合	返回字时间戳信息。

字时间戳信息（`Word`）

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public long getBeginTime()`	无	字开始时间，单位为ms	返回字开始时间。
`public long getEndTime()`	无	字结束时间，单位为ms	返回字结束时间。
`public String getText()`	无	字	返回识别的字。

同步调用结果（`TranslationRecognizerResultPack`）

在同步调用中，返回结果会包含流式结果中所有成句（isSentenceEnd为true）的内容。

接口/方法	参数	返回值	描述

接口/方法	参数	返回值	描述
`public String getRequestId()`	无	本次任务的请求ID	返回本次任务的请求ID。
`public ArrayList<TranscriptionResult> getTranscriptionResultList()`	无	识别结果（TranscriptionResult）	返回语音识别结果。
`public ArrayList<TranslationResult> getTranslationResultList()`	无	翻译结果（TranslationResult）	返回语音翻译结果。
`public ArrayList<TranslationRecognizerUsage> getUsageList()`	无	计费信息	返回计费信息。
`public Throwable getError()`	无	异常信息	返回异常信息。

错误码

在使用API过程中，如果调用失败并返回错误信息，请参见错误信息进行解决。

常见问题

请参见GitHub QA。

前提条件

模型列表

快速开始

流式调用：基于回调

流式调用：基于Flowable

同步调用

请求参数

关键接口

TranslationRecognizerRealtime类

回调接口（ResultCallback）

响应结果

实时识别/翻译结果（TranslationRecognizerResult）

识别结果（TranscriptionResult）

翻译结果（TranslationResult）

某语种对应的翻译结果（Translation）

后一句未断句识别结果（Stash）

字时间戳信息（Word）

同步调用结果（TranslationRecognizerResultPack）

错误码

更多示例