Alibaba Cloud Model Studio:Bahasa Markup Sintesis Ucapan (SSML)

Panggilan non-streaming

import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesisParam;
import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesizer;
import com.alibaba.dashscope.utils.Constants;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

/**
 * Catatan fitur SSML:
 *     1. SSML hanya didukung untuk panggilan non-streaming dan panggilan streaming unidirectional.
 *     2. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2,
 *        serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash).
 */
public class Main {
    private static String model = "cosyvoice-v3-flash";
    private static String voice = "longanyang";

    public static void main(String[] args) {
        // Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference
        Constants.baseWebsocketApiUrl = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference";
        streamAudioDataToSpeaker();
        System.exit(0);
    }

    public static void streamAudioDataToSpeaker() {
        SpeechSynthesisParam param =
                SpeechSynthesisParam.builder()
                        // Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
                        // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: .apiKey("sk-xxx")
                        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                        .model(model)
                        .voice(voice)
                        .build();

        SpeechSynthesizer synthesizer = new SpeechSynthesizer(param, null);
        ByteBuffer audio = null;
        try {
            // Panggilan non-streaming; diblokir hingga audio dikembalikan
            // Escape karakter khusus
            audio = synthesizer.call("<speak rate=\"2\">Laju bicara saya lebih cepat daripada orang normal.</speak>");
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            // Tutup koneksi WebSocket setelah tugas selesai
            synthesizer.getDuplexApi().close(1000, "bye");
        }
        if (audio != null) {
            // Simpan data audio ke file lokal bernama "output.mp3"
            File file = new File("output.mp3");
            try (FileOutputStream fos = new FileOutputStream(file)) {
                fos.write(audio.array());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        // Latensi paket pertama mencakup waktu yang diperlukan untuk membuat koneksi WebSocket
        System.out.println(
                "[Metric] Request ID: "
                        + synthesizer.getLastRequestId()
                        + ", Latensi paket pertama (ms): "
                        + synthesizer.getFirstPackageDelay());
    }
}

Panggilan streaming unidirectional

import com.alibaba.dashscope.audio.tts.SpeechSynthesisResult;
import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesisAudioFormat;
import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesisParam;
import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesizer;
import com.alibaba.dashscope.common.ResultCallback;
import com.alibaba.dashscope.utils.Constants;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * Catatan fitur SSML:
 *     1. SSML hanya didukung untuk panggilan non-streaming dan panggilan streaming unidirectional.
 *     2. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2,
 *        serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash).
 */
public class Main {
    private static String model = "cosyvoice-v3-flash";
    private static String voice = "longanyang";

    public static void main(String[] args) {
        // Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference
        Constants.baseWebsocketApiUrl = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference";
        streamAudioDataToSpeaker();
        System.out.println("Audio disimpan ke output.mp3");
        System.exit(0);
    }

    public static void streamAudioDataToSpeaker() {
        CountDownLatch latch = new CountDownLatch(1);
        final FileOutputStream[] fileOutputStream = new FileOutputStream[1];

        try {
            fileOutputStream[0] = new FileOutputStream("output.mp3");
        } catch (IOException e) {
            System.err.println("Gagal membuat file output: " + e.getMessage());
            return;
        }

        // Implementasikan antarmuka ResultCallback
        ResultCallback<SpeechSynthesisResult> callback = new ResultCallback<SpeechSynthesisResult>() {
            @Override
            public void onEvent(SpeechSynthesisResult result) {
                if (result.getAudioFrame() != null) {
                    // Tulis data audio ke file lokal
                    try {
                        byte[] audioData = result.getAudioFrame().array();
                        fileOutputStream[0].write(audioData);
                        fileOutputStream[0].flush();
                    } catch (IOException e) {
                        System.err.println("Gagal menulis data audio: " + e.getMessage());
                    }
                }
            }

            @Override
            public void onComplete() {
                System.out.println("Menerima Complete; sintesis suara selesai");
                closeFileOutputStream(fileOutputStream[0]);
                latch.countDown();
            }

            @Override
            public void onError(Exception e) {
                System.out.println("Terjadi kesalahan: " + e.toString());
                closeFileOutputStream(fileOutputStream[0]);
                latch.countDown();
            }
        };

        SpeechSynthesisParam param =
                SpeechSynthesisParam.builder()
                        // Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
                        // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: .apiKey("sk-xxx")
                        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                        .model(model)
                        .voice(voice)
                        .format(SpeechSynthesisAudioFormat.MP3_22050HZ_MONO_256KBPS)
                        .build();

        SpeechSynthesizer synthesizer = new SpeechSynthesizer(param, callback);

        try {
            // Panggilan streaming unidirectional; langsung mengembalikan null (hasil dikirim secara asinkron melalui callback)
            // Escape karakter khusus
            synthesizer.call("<speak rate=\"2\">Laju bicara saya lebih cepat daripada orang normal.</speak>");
            // Tunggu hingga sintesis selesai
            latch.await();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            // Tutup koneksi WebSocket setelah tugas selesai
            try {
                synthesizer.getDuplexApi().close(1000, "bye");
            } catch (Exception e) {
                System.err.println("Gagal menutup koneksi WebSocket: " + e.getMessage());
            }

            // Pastikan aliran file ditutup
            closeFileOutputStream(fileOutputStream[0]);
        }

        // Latensi paket pertama mencakup waktu yang diperlukan untuk membuat koneksi WebSocket
        System.out.println(
                "[Metric] Request ID: "
                        + synthesizer.getLastRequestId()
                        + ", Latensi paket pertama (ms): "
                        + synthesizer.getFirstPackageDelay());
    }

    private static void closeFileOutputStream(FileOutputStream fileOutputStream) {
        try {
            if (fileOutputStream != null) {
                fileOutputStream.close();
            }
        } catch (IOException e) {
            System.err.println("Gagal menutup aliran file: " + e.getMessage());
        }
    }
}

Panggilan non-streaming

# coding=utf-8
# Catatan fitur SSML:
#     1. SSML hanya didukung untuk panggilan non-streaming dan panggilan streaming unidirectional.
#     2. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2,
#        serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash)

import dashscope
from dashscope.audio.tts_v2 import *
import os

# Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
# Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.environ.get('DASHSCOPE_API_KEY')

# Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference
dashscope.base_websocket_api_url='wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference'

# Model
model = "cosyvoice-v3-flash"
# Voice
voice = "longanyang"

# Buat instance SpeechSynthesizer dan teruskan model, voice, dan parameter permintaan lainnya ke konstruktor
synthesizer = SpeechSynthesizer(model=model, voice=voice)
# Panggilan non-streaming; diblokir hingga audio dikembalikan
# Escape karakter khusus
audio = synthesizer.call("<speak rate=\"2\">Laju bicara saya lebih cepat daripada orang normal.</speak>")

# Simpan audio secara lokal
with open('output.mp3', 'wb') as f:
    f.write(audio)

# Latensi paket pertama mencakup waktu yang diperlukan untuk membuat koneksi WebSocket
print('[Metric] Request ID: {}, Latensi paket pertama: {} ms'.format(
    synthesizer.get_last_request_id(),
    synthesizer.get_first_package_delay()))

Panggilan streaming unidirectional

# coding=utf-8
# Catatan fitur SSML:
#     1. SSML hanya didukung untuk panggilan non-streaming dan panggilan streaming unidirectional.
#     2. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2,
#        serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash)

import dashscope
from dashscope.audio.tts_v2 import *
import os
from datetime import datetime

def get_timestamp():
    now = datetime.now()
    formatted_timestamp = now.strftime("[%Y-%m-%d %H:%M:%S.%f]")
    return formatted_timestamp

# Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
# Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.environ.get('DASHSCOPE_API_KEY')

# Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference
dashscope.base_websocket_api_url='wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference'

# Model
model = "cosyvoice-v3-flash"
# Voice
voice = "longanyang"

# Definisikan antarmuka callback
class Callback(ResultCallback):
    _player = None
    _stream = None

    def on_open(self):
        # Buka file output untuk menulis data audio
        self.file = open("output.mp3", "wb")
        print("Koneksi berhasil dibuat: " + get_timestamp())

    def on_complete(self):
        print("Sintesis suara selesai; semua hasil diterima: " + get_timestamp())
        if hasattr(self, 'file') and self.file:
            self.file.close()
        self
        # Latensi paket pertama mencakup waktu yang diperlukan untuk membuat koneksi WebSocket
        print('[Metric] Request ID: {}, Latensi paket pertama: {} ms'.format(
            self.synthesizer.get_last_request_id(),
            self.synthesizer.get_first_package_delay()))

    def on_error(self, message: str):
        print(f"Kesalahan sintesis suara: {message}")
        if hasattr(self, 'file') and self.file:
            self.file.close()

    def on_close(self):
        print("Koneksi ditutup: " + get_timestamp())
        if hasattr(self, 'file') and self.file:
            self.file.close()

    def on_event(self, message):
        pass

    def on_data(self, data: bytes) -> None:
        print(get_timestamp() + " Panjang audio biner: " + str(len(data)))
        # Tulis data audio ke file
        self.file.write(data)

callback = Callback()

# Buat instance SpeechSynthesizer dan teruskan model, voice, dan parameter permintaan lainnya ke konstruktor
synthesizer = SpeechSynthesizer(
    model=model,
    voice=voice,
    callback=callback,
)

# Tetapkan instance synthesizer ke callback untuk digunakan dalam on_complete
callback.synthesizer = synthesizer

# Panggilan streaming unidirectional; kirim teks untuk disintesis dan terima audio biner secara real-time melalui metode on_data dari callback
# Escape karakter khusus
synthesizer.call("<speak rate=\"2\">Laju bicara saya lebih cepat daripada orang normal.</speak>")

Go

// Catatan fitur SSML:
//     1. Atur parameter enable_ssml ke true dalam perintah run-task untuk mengaktifkan SSML.
//     2. Kirim teks SSML menggunakan perintah continue-task; Anda hanya dapat mengirim perintah ini sekali.
//     3. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2,
//        serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash)

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "strings"
    "time"

    "github.com/google/uuid"
    "github.com/gorilla/websocket"
)

const (
    // Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference/
    wsURL      = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/"
    outputFile = "output.mp3"
)

func main() {
    // Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: apiKey := "sk-xxx"
    apiKey := os.Getenv("DASHSCOPE_API_KEY")

    // Hapus file output
    os.Remove(outputFile)
    os.Create(outputFile)

    // Hubungkan ke WebSocket
    header := make(http.Header)
    header.Add("X-DashScope-DataInspection", "enable")
    header.Add("Authorization", fmt.Sprintf("bearer %s", apiKey))

    conn, resp, err := websocket.DefaultDialer.Dial(wsURL, header)
    if err != nil {
        if resp != nil {
            fmt.Printf("Koneksi gagal. Kode status HTTP: %d\n", resp.StatusCode)
        }
        fmt.Println("Koneksi gagal:", err)
        return
    }
    defer conn.Close()

    // Hasilkan ID tugas
    taskID := uuid.New().String()
    fmt.Printf("ID tugas yang dihasilkan: %s\n", taskID)

    // Kirim perintah run-task
    runTaskCmd := map[string]interface{}{
        "header": map[string]interface{}{
            "action":    "run-task",
            "task_id":   taskID,
            "streaming": "duplex",
        },
        "payload": map[string]interface{}{
            "task_group": "audio",
            "task":       "tts",
            "function":   "SpeechSynthesizer",
            "model":      "cosyvoice-v3-flash",
            "parameters": map[string]interface{}{
                "text_type":   "PlainText",
                "voice":       "longanyang",
                "format":      "mp3",
                "sample_rate": 22050,
                "volume":      50,
                "rate":        1,
                "pitch":       1,
                // Jika enable_ssml diatur ke true, Anda hanya dapat mengirim perintah continue-task sekali.
                // Jika tidak, Anda akan mendapatkan kesalahan "Text request limit violated, expected 1."
                "enable_ssml": true,
            },
            "input": map[string]interface{}{},
        },
    }

    runTaskJSON, _ := json.Marshal(runTaskCmd)
    fmt.Printf("Mengirim perintah run-task: %s\n", string(runTaskJSON))

    err = conn.WriteMessage(websocket.TextMessage, runTaskJSON)
    if err != nil {
        fmt.Println("Gagal mengirim run-task:", err)
        return
    }

    textSent := false

    // Proses pesan
    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            fmt.Println("Gagal membaca pesan:", err)
            break
        }

        // Tangani pesan biner
        if messageType == websocket.BinaryMessage {
            fmt.Printf("Menerima pesan biner, panjang: %d\n", len(message))
            file, _ := os.OpenFile(outputFile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
            file.Write(message)
            file.Close()
            continue
        }

        // Tangani pesan teks
        messageStr := string(message)
        fmt.Printf("Menerima pesan teks: %s\n", strings.ReplaceAll(messageStr, "\n", ""))

        // Uraikan JSON untuk mendapatkan jenis event
        var msgMap map[string]interface{}
        if json.Unmarshal(message, &msgMap) == nil {
            if header, ok := msgMap["header"].(map[string]interface{}); ok {
                if event, ok := header["event"].(string); ok {
                    fmt.Printf("Jenis event: %s\n", event)

                    switch event {
                    case "task-started":
                        fmt.Println("=== Menerima event task-started ===")

                        if !textSent {
                            // Kirim perintah continue-task; saat menggunakan SSML, Anda hanya dapat mengirim perintah ini sekali
                            continueTaskCmd := map[string]interface{}{
                                "header": map[string]interface{}{
                                    "action":    "continue-task",
                                    "task_id":   taskID,
                                    "streaming": "duplex",
                                },
                                "payload": map[string]interface{}{
                                    "input": map[string]interface{}{
                                        // Escape karakter khusus
                                        "text": "<speak rate=\"2\">Laju bicara saya lebih cepat daripada orang normal.</speak>",
                                    },
                                },
                            }

                            continueTaskJSON, _ := json.Marshal(continueTaskCmd)
                            fmt.Printf("Mengirim perintah continue-task: %s\n", string(continueTaskJSON))

                            err = conn.WriteMessage(websocket.TextMessage, continueTaskJSON)
                            if err != nil {
                                fmt.Println("Gagal mengirim continue-task:", err)
                                return
                            }

                            textSent = true

                            // Tunda pengiriman finish-task
                            time.Sleep(500 * time.Millisecond)

                            // Kirim perintah finish-task
                            finishTaskCmd := map[string]interface{}{
                                "header": map[string]interface{}{
                                    "action":    "finish-task",
                                    "task_id":   taskID,
                                    "streaming": "duplex",
                                },
                                "payload": map[string]interface{}{
                                    "input": map[string]interface{}{},
                                },
                            }

                            finishTaskJSON, _ := json.Marshal(finishTaskCmd)
                            fmt.Printf("Mengirim perintah finish-task: %s\n", string(finishTaskJSON))

                            err = conn.WriteMessage(websocket.TextMessage, finishTaskJSON)
                            if err != nil {
                                fmt.Println("Gagal mengirim finish-task:", err)
                                return
                            }
                        }

                    case "task-finished":
                        fmt.Println("=== Tugas selesai ===")
                        return

                    case "task-failed":
                        fmt.Println("=== Tugas gagal ===")
                        if header["error_message"] != nil {
                            fmt.Printf("Pesan kesalahan: %s\n", header["error_message"])
                        }
                        return

                    case "result-generated":
                        fmt.Println("Menerima event result-generated")
                    }
                }
            }
        }
    }
}

C#

using System.Net.WebSockets;
using System.Text;
using System.Text.Json;

// Catatan fitur SSML:
//     1. Atur parameter enable_ssml ke true dalam perintah run-task untuk mengaktifkan SSML.
//     2. Kirim teks SSML menggunakan perintah continue-task; Anda hanya dapat mengirim perintah ini sekali.
//     3. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2,
//        serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash)
class Program {
    // Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: private static readonly string ApiKey = "sk-xxx"
    private static readonly string ApiKey = Environment.GetEnvironmentVariable("DASHSCOPE_API_KEY") ?? throw new InvalidOperationException("Variabel lingkungan DASHSCOPE_API_KEY belum diatur.");

    // Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference/
    private const string WebSocketUrl = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/";
    // Jalur file output
    private const string OutputFilePath = "output.mp3";

    // Klien WebSocket
    private static ClientWebSocket _webSocket = new ClientWebSocket();
    // Sumber token pembatalan
    private static CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
    // ID tugas
    private static string? _taskId;
    // Apakah tugas telah dimulai
    private static TaskCompletionSource<bool> _taskStartedTcs = new TaskCompletionSource<bool>();

    static async Task Main(string[] args) {
        try {
            // Hapus file output
            ClearOutputFile(OutputFilePath);

            // Hubungkan ke layanan WebSocket
            await ConnectToWebSocketAsync(WebSocketUrl);

            // Mulai tugas untuk menerima pesan
            Task receiveTask = ReceiveMessagesAsync();

            // Kirim perintah run-task
            _taskId = GenerateTaskId();
            await SendRunTaskCommandAsync(_taskId);

            // Tunggu event task-started
            await _taskStartedTcs.Task;

            // Kirim perintah continue-task. Saat menggunakan fitur SSML, perintah ini hanya dapat dikirim sekali.
            // Karakter khusus perlu di-escape.
            await SendContinueTaskCommandAsync("<speak rate=\"2\">Laju bicara saya lebih cepat daripada orang normal.</speak>");

            // Kirim perintah finish-task
            await SendFinishTaskCommandAsync(_taskId);

            // Tunggu hingga tugas penerimaan selesai
            await receiveTask;

            Console.WriteLine("Tugas selesai, koneksi ditutup.");
        } catch (OperationCanceledException) {
            Console.WriteLine("Tugas dibatalkan.");
        } catch (Exception ex) {
            Console.WriteLine($"Terjadi kesalahan: {ex.Message}");
        } finally {
            _cancellationTokenSource.Cancel();
            _webSocket.Dispose();
        }
    }

    private static void ClearOutputFile(string filePath) {
        if (File.Exists(filePath)) {
            File.WriteAllText(filePath, string.Empty);
            Console.WriteLine("File output telah dihapus.");
        } else {
            Console.WriteLine("File output tidak ada dan tidak perlu dihapus.");
        }
    }

    private static async Task ConnectToWebSocketAsync(string url) {
        var uri = new Uri(url);
        if (_webSocket.State == WebSocketState.Connecting || _webSocket.State == WebSocketState.Open) {
            return;
        }

        // Atur header untuk koneksi WebSocket
        _webSocket.Options.SetRequestHeader("Authorization", $"bearer {ApiKey}");
        _webSocket.Options.SetRequestHeader("X-DashScope-DataInspection", "enable");

        try {
            await _webSocket.ConnectAsync(uri, _cancellationTokenSource.Token);
            Console.WriteLine("Berhasil terhubung ke layanan WebSocket.");
        } catch (OperationCanceledException) {
            Console.WriteLine("Koneksi WebSocket dibatalkan.");
        } catch (Exception ex) {
            Console.WriteLine($"Koneksi WebSocket gagal: {ex.Message}");
            throw;
        }
    }

    private static async Task SendRunTaskCommandAsync(string taskId) {
        var command = CreateCommand("run-task", taskId, "duplex", new {
            task_group = "audio",
            task = "tts",
            function = "SpeechSynthesizer",
            model = "cosyvoice-v3-flash",
            parameters = new
            {
                text_type = "PlainText",
                voice = "longanyang",
                format = "mp3",
                sample_rate = 22050,
                volume = 50,
                rate = 1,
                pitch = 1,
                // Jika enable_ssml diatur ke true, Anda hanya dapat mengirim perintah continue-task sekali.
                // Jika tidak, Anda akan mendapatkan kesalahan "Text request limit violated, expected 1."
                enable_ssml = true
            },
            input = new { }
        });

        await SendJsonMessageAsync(command);
        Console.WriteLine("Perintah run-task dikirim.");
    }

    private static async Task SendContinueTaskCommandAsync(string text) {
        if (_taskId == null) {
            throw new InvalidOperationException("ID tugas belum diinisialisasi.");
        }

        var command = CreateCommand("continue-task", _taskId, "duplex", new {
            input = new {
                text
            }
        });

        await SendJsonMessageAsync(command);
        Console.WriteLine("Perintah continue-task dikirim.");
    }

    private static async Task SendFinishTaskCommandAsync(string taskId) {
        var command = CreateCommand("finish-task", taskId, "duplex", new {
            input = new { }
        });

        await SendJsonMessageAsync(command);
        Console.WriteLine("Perintah finish-task dikirim.");
    }

    private static async Task SendJsonMessageAsync(string message) {
        var buffer = Encoding.UTF8.GetBytes(message);
        try {
            await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
        } catch (OperationCanceledException) {
            Console.WriteLine("Pengiriman pesan dibatalkan.");
        }
    }

    private static async Task ReceiveMessagesAsync() {
        while (_webSocket.State == WebSocketState.Open) {
            var response = await ReceiveMessageAsync();
            if (response != null) {
                var eventStr = response.RootElement.GetProperty("header").GetProperty("event").GetString();
                switch (eventStr) {
                    case "task-started":
                        Console.WriteLine("Tugas dimulai.");
                        _taskStartedTcs.TrySetResult(true);
                        break;
                    case "task-finished":
                        Console.WriteLine("Tugas selesai.");
                        _cancellationTokenSource.Cancel();
                        break;
                    case "task-failed":
                        Console.WriteLine("Tugas gagal: " + response.RootElement.GetProperty("header").GetProperty("error_message").GetString());
                        _cancellationTokenSource.Cancel();
                        break;
                    default:
                        // result-generated dapat ditangani di sini
                        break;
                }
            }
        }
    }

    private static async Task<JsonDocument?> ReceiveMessageAsync() {
        var buffer = new byte[1024 * 4];
        var segment = new ArraySegment<byte>(buffer);

        try {
            WebSocketReceiveResult result = await _webSocket.ReceiveAsync(segment, _cancellationTokenSource.Token);

            if (result.MessageType == WebSocketMessageType.Close) {
                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", _cancellationTokenSource.Token);
                return null;
            }

            if (result.MessageType == WebSocketMessageType.Binary) {
                // Tangani data biner
                Console.WriteLine("Menerima data biner...");

                // Simpan data biner ke file
                using (var fileStream = new FileStream(OutputFilePath, FileMode.Append)) {
                    fileStream.Write(buffer, 0, result.Count);
                }

                return null;
            }

            string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
            return JsonDocument.Parse(message);
        } catch (OperationCanceledException) {
            Console.WriteLine("Penerimaan pesan dibatalkan.");
            return null;
        }
    }

    private static string GenerateTaskId() {
        return Guid.NewGuid().ToString("N").Substring(0, 32);
    }

    private static string CreateCommand(string action, string taskId, string streaming, object payload) {
        var command = new {
            header = new {
                action,
                task_id = taskId,
                streaming
            },
            payload
        };

        return JsonSerializer.Serialize(command);
    }
}

PHP

Kode contoh memiliki struktur direktori sebagai berikut:

my-php-project/

├── composer.json

├── vendor/

└── index.php

Berikut adalah isi dari composer.json. Tentukan nomor versi dependensi berdasarkan kebutuhan aktual Anda:

{
    "require": {
        "react/event-loop": "^1.3",
        "react/socket": "^1.11",
        "react/stream": "^1.2",
        "react/http": "^1.1",
        "ratchet/pawl": "^0.4"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Berikut adalah isi dari index.php:

<!-- Catatan fitur SSML: -->
<!--     1. Saat mengirim perintah run-task, atur parameter enable_ssml ke true untuk mengaktifkan dukungan SSML. -->
<!--     2. Kirim teks yang berisi SSML dengan menggunakan perintah continue-task. Anda hanya dapat mengirim perintah ini sekali. -->
<!--     3. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2, serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash). -->

<?php

require __DIR__ . '/vendor/autoload.php';

use Ratchet\Client\Connector;
use React\EventLoop\Loop;
use React\Socket\Connector as SocketConnector;

// Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
// Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: $api_key = "sk-xxx"
$api_key = getenv("DASHSCOPE_API_KEY");
// URL berikut untuk wilayah Singapura. Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference/
$websocket_url = 'wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/'; // Alamat server WebSocket
$output_file = 'output.mp3'; // Jalur file output

$loop = Loop::get();

if (file_exists($output_file)) {
    // Hapus isi file
    file_put_contents($output_file, '');
}

// Buat konektor kustom
$socketConnector = new SocketConnector($loop, [
    'tcp' => [
        'bindto' => '0.0.0.0:0',
    ],
    'tls' => [
        'verify_peer' => false,
        'verify_peer_name' => false,
    ],
]);

$connector = new Connector($loop, $socketConnector);

$headers = [
    'Authorization' => 'bearer ' . $api_key,
    'X-DashScope-DataInspection' => 'enable'
];

$connector($websocket_url, [], $headers)->then(function ($conn) use ($loop, $output_file) {
    echo "Terhubung ke server WebSocket\n";

    // Hasilkan ID tugas
    $taskId = generateTaskId();

    // Kirim perintah run-task
    sendRunTaskMessage($conn, $taskId);

    // Definisikan fungsi untuk mengirim perintah continue-task
    $sendContinueTask = function() use ($conn, $loop, $taskId) {
        // Kirim perintah continue-task. Saat menggunakan fitur SSML, perintah ini hanya dapat dikirim sekali.
        $continueTaskMessage = json_encode([
            "header" => [
                "action" => "continue-task",
                "task_id" => $taskId,
                "streaming" => "duplex"
            ],
            "payload" => [
                "input" => [
                    // Karakter khusus perlu di-escape
                    "text" => "<speak rate=\"2\">Laju bicara saya lebih cepat daripada orang normal.</speak>"
                ]
            ]
        ]);
        $conn->send($continueTaskMessage);

        // Kirim perintah finish-task
        sendFinishTaskMessage($conn, $taskId);
    };

    // Bendera untuk memeriksa apakah event task-started diterima
    $taskStarted = false;

    // Dengarkan pesan
    $conn->on('message', function($msg) use ($conn, $sendContinueTask, $loop, &$taskStarted, $taskId, $output_file) {
        if ($msg->isBinary()) {
            // Tulis data biner ke file lokal
            file_put_contents($output_file, $msg->getPayload(), FILE_APPEND);
        } else {
            // Tangani pesan non-biner
            $response = json_decode($msg, true);

            if (isset($response['header']['event'])) {
                handleEvent($conn, $response, $sendContinueTask, $loop, $taskId, $taskStarted);
            } else {
                echo "Format pesan tidak dikenal\n";
            }
        }
    });

    // Dengarkan penutupan koneksi
    $conn->on('close', function($code = null, $reason = null) {
        echo "Koneksi ditutup\n";
        if ($code !== null) {
            echo "Kode tutup: " . $code . "\n";
        }
        if ($reason !== null) {
            echo "Alasan tutup: " . $reason . "\n";
        }
    });
}, function ($e) {
    echo "Tidak dapat terhubung: {$e->getMessage()}\n";
});

$loop->run();

/**
 * Hasilkan ID tugas
 * @return string
 */
function generateTaskId(): string {
    return bin2hex(random_bytes(16));
}

/**
 * Kirim perintah run-task
 * @param $conn
 * @param $taskId
 */
function sendRunTaskMessage($conn, $taskId) {
    $runTaskMessage = json_encode([
        "header" => [
            "action" => "run-task",
            "task_id" => $taskId,
            "streaming" => "duplex"
        ],
        "payload" => [
            "task_group" => "audio",
            "task" => "tts",
            "function" => "SpeechSynthesizer",
            "model" => "cosyvoice-v3-flash",
            "parameters" => [
                "text_type" => "PlainText",
                "voice" => "longanyang",
                "format" => "mp3",
                "sample_rate" => 22050,
                "volume" => 50,
                "rate" => 1,
                "pitch" => 1,
                // Jika enable_ssml diatur ke true, Anda hanya dapat mengirim perintah continue-task sekali.
                // Jika tidak, Anda akan mendapatkan kesalahan "Text request limit violated, expected 1."
                "enable_ssml" => true
            ],
            "input" => (object) []
        ]
    ]);
    echo "Bersiap mengirim perintah run-task: " . $runTaskMessage . "\n";
    $conn->send($runTaskMessage);
    echo "Perintah run-task dikirim\n";
}

/**
 * Baca file audio
 * @param string $filePath
 * @return bool|string
 */
function readAudioFile(string $filePath) {
    $voiceData = file_get_contents($filePath);
    if ($voiceData === false) {
        echo "Gagal membaca file audio\n";
    }
    return $voiceData;
}

/**
 * Pisahkan data audio
 * @param string $data
 * @param int $chunkSize
 * @return array
 */
function splitAudioData(string $data, int $chunkSize): array {
    return str_split($data, $chunkSize);
}

/**
 * Kirim perintah finish-task
 * @param $conn
 * @param $taskId
 */
function sendFinishTaskMessage($conn, $taskId) {
    $finishTaskMessage = json_encode([
        "header" => [
            "action" => "finish-task",
            "task_id" => $taskId,
            "streaming" => "duplex"
        ],
        "payload" => [
            "input" => (object) []
        ]
    ]);
    echo "Bersiap mengirim perintah finish-task: " . $finishTaskMessage . "\n";
    $conn->send($finishTaskMessage);
    echo "Perintah finish-task dikirim\n";
}

/**
 * Tangani event
 * @param $conn
 * @param $response
 * @param $sendContinueTask
 * @param $loop
 * @param $taskId
 * @param $taskStarted
 */
function handleEvent($conn, $response, $sendContinueTask, $loop, $taskId, &$taskStarted) {
    switch ($response['header']['event']) {
        case 'task-started':
            echo "Tugas dimulai, mengirim perintah continue-task...\n";
            $taskStarted = true;
            // Kirim perintah continue-task
            $sendContinueTask();
            break;
        case 'result-generated':
            // Abaikan event result-generated
            break;
        case 'task-finished':
            echo "Tugas selesai\n";
            $conn->close();
            break;
        case 'task-failed':
            echo "Tugas gagal\n";
            echo "Kode kesalahan: " . $response['header']['error_code'] . "\n";
            echo "Pesan kesalahan: " . $response['header']['error_message'] . "\n";
            $conn->close();
            break;
        case 'error':
            echo "Kesalahan: " . $response['payload']['message'] . "\n";
            break;
        default:
            echo "Event tidak dikenal: " . $response['header']['event'] . "\n";
            break;
    }

    // Jika tugas selesai, tutup koneksi
    if ($response['header']['event'] == 'task-finished') {
        // Tunggu 1 detik untuk memastikan semua data ditransfer
        $loop->addTimer(1, function() use ($conn) {
            $conn->close();
            echo "Klien menutup koneksi\n";
        });
    }

    // Jika event task-started tidak diterima, tutup koneksi
    if (!$taskStarted && in_array($response['header']['event'], ['task-failed', 'error'])) {
        $conn->close();
    }
}

Node.js

Anda perlu menginstal dependensi yang diperlukan:

npm install ws
npm install uuid

Kode contohnya sebagai berikut:

// Catatan fitur SSML:
//     1. Atur parameter enable_ssml ke true dalam perintah run-task untuk mengaktifkan SSML.
//     2. Kirim teks SSML menggunakan perintah continue-task; Anda hanya dapat mengirim perintah ini sekali.
//     3. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2,
//        serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash)

import fs from 'fs';
import WebSocket from 'ws';
import { v4 as uuid } from 'uuid'; // Digunakan untuk menghasilkan UUID

// Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
// Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: const apiKey = "sk-xxx"
const apiKey = process.env.DASHSCOPE_API_KEY;
// URL berikut untuk wilayah Singapura. Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference/
const url = 'wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/';
// Jalur file output
const outputFilePath = 'output.mp3';

// Hapus file output
fs.writeFileSync(outputFilePath, '');

// Buat klien WebSocket
const ws = new WebSocket(url, {
  headers: {
    Authorization: `bearer ${apiKey}`,
    'X-DashScope-DataInspection': 'enable'
  }
});

let taskStarted = false;
let taskId = uuid();

ws.on('open', () => {
  console.log('Terhubung ke server WebSocket');

  // Kirim perintah run-task
  const runTaskMessage = JSON.stringify({
    header: {
      action: 'run-task',
      task_id: taskId,
      streaming: 'duplex'
    },
    payload: {
      task_group: 'audio',
      task: 'tts',
      function: 'SpeechSynthesizer',
      model: 'cosyvoice-v3-flash',
      parameters: {
        text_type: 'PlainText',
        voice: 'longanyang', // Voice
        format: 'mp3', // Format audio
        sample_rate: 22050, // Laju sampel
        volume: 50, // Volume
        rate: 1, // Laju ucapan
        pitch: 1, // Pitch
        enable_ssml: true // Apakah akan mengaktifkan fitur SSML. Jika enable_ssml diatur ke true, Anda hanya dapat mengirim perintah continue-task sekali. Jika tidak, kesalahan "Text request limit violated, expected 1." dilaporkan.
      },
      input: {}
    }
  });
  ws.send(runTaskMessage);
  console.log('Pesan run-task dikirim');
});

const fileStream = fs.createWriteStream(outputFilePath, { flags: 'a' });
ws.on('message', (data, isBinary) => {
  if (isBinary) {
    // Tulis data biner ke file
    fileStream.write(data);
  } else {
    const message = JSON.parse(data);

    switch (message.header.event) {
      case 'task-started':
        taskStarted = true;
        console.log('Tugas telah dimulai');
        // Kirim perintah continue-task
        sendContinueTasks(ws);
        break;
      case 'task-finished':
        console.log('Tugas telah selesai');
        ws.close();
        fileStream.end(() => {
          console.log('Aliran file telah ditutup');
        });
        break;
      case 'task-failed':
        console.error('Tugas gagal: ', message.header.error_message);
        ws.close();
        fileStream.end(() => {
          console.log('Aliran file telah ditutup');
        });
        break;
      default:
        // Anda dapat menangani result-generated di sini
        break;
    }
  }
});

function sendContinueTasks(ws) {
  
  if (taskStarted) {
    // Kirim perintah continue-task. Saat menggunakan fitur SSML, perintah ini hanya dapat dikirim sekali.
    const continueTaskMessage = JSON.stringify({
      header: {
        action: 'continue-task',
        task_id: taskId,
        streaming: 'duplex'
      },
      payload: {
        input: {
          // Karakter khusus perlu di-escape
          text: '<speak rate="2">Laju bicara saya lebih cepat daripada orang normal.</speak>'
        }
      }
    });
    ws.send(continueTaskMessage);
    
    // Kirim perintah finish-task
    const finishTaskMessage = JSON.stringify({
      header: {
        action: 'finish-task',
        task_id: taskId,
        streaming: 'duplex'
      },
      payload: {
        input: {}
      }
    });
    ws.send(finishTaskMessage);
  }
}

ws.on('close', () => {
  console.log('Terputus dari server WebSocket');
});

Java

Jika Anda menggunakan bahasa pemrograman Java, kami menyarankan Anda menggunakan Java DashScope SDK untuk pengembangan. Untuk informasi selengkapnya, lihat Java SDK.

Berikut adalah contoh WebSocket Java. Sebelum menjalankan contoh, pastikan Anda telah mengimpor dependensi berikut:

• Java-WebSocket

• jackson-databind

Kami menyarankan Anda menggunakan Maven atau Gradle untuk mengelola paket dependensi. Konfigurasinya sebagai berikut:

<dependencies>
    <!-- WebSocket Client -->
    <dependency>
        <groupId>org.java-websocket</groupId>
        <artifactId>Java-WebSocket</artifactId>
        <version>1.5.3</version>
    </dependency>

    <!-- JSON Processing -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.13.0</version>
    </dependency>
</dependencies>

// Omit other code
dependencies {
  // WebSocket Client
  implementation 'org.java-websocket:Java-WebSocket:1.5.3'
  // JSON Processing
  implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.0'
}
// Omit other code

Kode Java-nya sebagai berikut:

import com.fasterxml.jackson.databind.ObjectMapper;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;

import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.nio.ByteBuffer;
import java.util.*;

/**
 * Catatan fitur SSML:
 *     1. Saat mengirim perintah run-task, atur parameter enable_ssml ke true untuk mengaktifkan dukungan SSML.
 *     2. Kirim teks yang berisi SSML dengan menggunakan perintah continue-task. Anda hanya dapat mengirim perintah ini sekali.
 *     3. SSML hanya didukung untuk voice yang dikloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2, serta voice sistem yang ditandai sebagai mendukung SSML dalam daftar voice (misalnya, voice longanyang untuk cosyvoice-v3-flash).
 */
public class TTSWebSocketClient extends WebSocketClient {
    private final String taskId = UUID.randomUUID().toString();
    private final String outputFile = "output_" + System.currentTimeMillis() + ".mp3";
    private boolean taskFinished = false;

    public TTSWebSocketClient(URI serverUri, Map<String, String> headers) {
        super(serverUri, headers);
    }

    @Override
    public void onOpen(ServerHandshake serverHandshake) {
        System.out.println("Koneksi berhasil");

        // Kirim perintah run-task
        // Jika enable_ssml diatur ke true, Anda hanya dapat mengirim perintah continue-task sekali.
        // Jika tidak, Anda akan mendapatkan kesalahan "Text request limit violated, expected 1."
        String runTaskCommand = "{ \"header\": { \"action\": \"run-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"task_group\": \"audio\", \"task\": \"tts\", \"function\": \"SpeechSynthesizer\", \"model\": \"cosyvoice-v3-flash\", \"parameters\": { \"text_type\": \"PlainText\", \"voice\": \"longanyang\", \"format\": \"mp3\", \"sample_rate\": 22050, \"volume\": 50, \"rate\": 1, \"pitch\": 1, \"enable_ssml\": true }, \"input\": {} }}";
        send(runTaskCommand);
    }

    @Override
    public void onMessage(String message) {
        System.out.println("Menerima pesan dari server: " + message);
        try {
            // Uraikan pesan JSON
            Map<String, Object> messageMap = new ObjectMapper().readValue(message, Map.class);

            if (messageMap.containsKey("header")) {
                Map<String, Object> header = (Map<String, Object>) messageMap.get("header");

                if (header.containsKey("event")) {
                    String event = (String) header.get("event");

                    if ("task-started".equals(event)) {
                        System.out.println("Menerima event task-started dari server");

                        // Kirim perintah continue-task. Saat menggunakan fitur SSML, perintah ini hanya dapat dikirim sekali.
                        // Karakter khusus perlu di-escape.
                        sendContinueTask("<speak rate=\\\"2\\\">Laju bicara saya lebih cepat daripada orang normal.</speak>");

                        // Kirim perintah finish-task
                        sendFinishTask();
                    } else if ("task-finished".equals(event)) {
                        System.out.println("Menerima event task-finished dari server");
                        taskFinished = true;
                        closeConnection();
                    } else if ("task-failed".equals(event)) {
                        System.out.println("Tugas gagal: " + message);
                        closeConnection();
                    }
                }
            }
        } catch (Exception e) {
            System.err.println("Terjadi pengecualian: " + e.getMessage());
        }
    }

    @Override
    public void onMessage(ByteBuffer message) {
        System.out.println("Ukuran data audio biner yang diterima: " + message.remaining());

        try (FileOutputStream fos = new FileOutputStream(outputFile, true)) {
            byte[] buffer = new byte[message.remaining()];
            message.get(buffer);
            fos.write(buffer);
            System.out.println("Data audio telah ditulis ke file lokal " + outputFile);
        } catch (IOException e) {
            System.err.println("Gagal menulis data audio ke file lokal: " + e.getMessage());
        }
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        System.out.println("Koneksi ditutup: " + reason + " (" + code + ")");
    }

    @Override
    public void onError(Exception ex) {
        System.err.println("Kesalahan: " + ex.getMessage());
        ex.printStackTrace();
    }

    private void sendContinueTask(String text) {
        String command = "{ \"header\": { \"action\": \"continue-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"input\": { \"text\": \"" + text + "\" } }}";
        send(command);
    }

    private void sendFinishTask() {
        String command = "{ \"header\": { \"action\": \"finish-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"input\": {} }}";
        send(command);
    }

    private void closeConnection() {
        if (!isClosed()) {
            close();
        }
    }

    public static void main(String[] args) {
        try {
            // Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
            // Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: String apiKey = "sk-xxx"
            String apiKey = System.getenv("DASHSCOPE_API_KEY");
            if (apiKey == null || apiKey.isEmpty()) {
                System.err.println("Harap atur variabel lingkungan DASHSCOPE_API_KEY");
                return;
            }

            Map<String, String> headers = new HashMap<>();
            headers.put("Authorization", "bearer " + apiKey);
            // Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference/
            TTSWebSocketClient client = new TTSWebSocketClient(new URI("wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/"), headers);

            client.connect();

            while (!client.isClosed() && !client.taskFinished) {
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            System.err.println("Gagal terhubung ke layanan WebSocket: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Python

Jika Anda menggunakan Python, kami merekomendasikan agar Anda menggunakan SDK DashScope Python untuk pengembangan; lihat SDK Python.

Berikut ini adalah contoh WebSocket Python. Sebelum menjalankan contoh ini, impor dependensi dengan cara berikut:

pip uninstall websocket-client
pip uninstall websocket
pip install websocket-client

# Catatan fitur SSML:
#     1. Saat mengirim perintah run-task, atur parameter enable_ssml ke true untuk mengaktifkan dukungan SSML.
#     2. Kirim teks yang berisi SSML dengan menggunakan perintah continue-task. Anda hanya dapat mengirim perintah ini sekali.
#     3. SSML didukung hanya untuk suara kloning dari model cosyvoice-v3-flash, cosyvoice-v3-plus, dan cosyvoice-v2, serta suara sistem yang ditandai sebagai didukung SSML dalam daftar suara (misalnya, suara longanyang untuk cosyvoice-v3-flash).

import websocket
import json
import uuid
import os
import time


class TTSClient:
    def __init__(self, api_key, uri):
        """
    Menginisialisasi instans TTSClient.

    Parameter:
        api_key (str): Kunci API untuk otentikasi.
        uri (str): Alamat layanan WebSocket.
    """
        self.api_key = api_key  # Ganti dengan kunci API Anda.
        self.uri = uri  # Ganti dengan alamat WebSocket Anda.
        self.task_id = str(uuid.uuid4())  # Hasilkan ID tugas unik.
        self.output_file = f"output_{int(time.time())}.mp3"  # Jalur file audio keluaran.
        self.ws = None  # Instans WebSocketApp.
        self.task_started = False  # Apakah event task-started telah diterima.
        self.task_finished = False  # Apakah event task-finished/task-failed telah diterima.

    def on_open(self, ws):
        """
    Fungsi callback saat koneksi WebSocket terbentuk.
    Mengirim perintah run-task untuk memulai tugas sintesis suara.
    """
        print("Koneksi WebSocket terbentuk")

        # Bangun perintah run-task.
        run_task_cmd = {
            "header": {
                "action": "run-task",
                "task_id": self.task_id,
                "streaming": "duplex"
            },
            "payload": {
                "task_group": "audio",
                "task": "tts",
                "function": "SpeechSynthesizer",
                "model": "cosyvoice-v3-flash",
                "parameters": {
                    "text_type": "PlainText",
                    "voice": "longanyang",
                    "format": "mp3",
                    "sample_rate": 22050,
                    "volume": 50,
                    "rate": 1,
                    "pitch": 1,
                    # Jika enable_ssml diatur ke true, Anda hanya dapat mengirim perintah continue-task sekali.
                    # Jika tidak, Anda akan mendapatkan kesalahan "Text request limit violated, expected 1."
                    "enable_ssml": True
                },
                "input": {}
            }
        }

        # Kirim perintah run-task.
        ws.send(json.dumps(run_task_cmd))
        print("Perintah run-task dikirim")

    def on_message(self, ws, message):
        """
    Fungsi callback saat pesan diterima.
    Menangani pesan teks dan pesan biner secara terpisah.
    """
        if isinstance(message, str):
            # Proses pesan teks JSON.
            try:
                msg_json = json.loads(message)
                print(f"Pesan JSON diterima: {msg_json}")

                if "header" in msg_json:
                    header = msg_json["header"]

                    if "event" in header:
                        event = header["event"]

                        if event == "task-started":
                            print("Tugas dimulai")
                            self.task_started = True

                            # Kirim perintah continue-task. Saat menggunakan fitur SSML, perintah ini hanya dapat dikirim sekali.
                            # Karakter khusus harus di-escape.
                            self.send_continue_task("<speak rate=\"2\">Laju berbicara saya lebih cepat daripada orang biasa.</speak>")

                            # Kirim finish-task setelah continue-task dikirim.
                            self.send_finish_task()

                        elif event == "task-finished":
                            print("Tugas selesai")
                            self.task_finished = True
                            self.close(ws)

                        elif event == "task-failed":
                            error_msg = msg_json.get("error_message", "Kesalahan tidak diketahui")
                            print(f"Tugas gagal: {error_msg}")
                            self.task_finished = True
                            self.close(ws)

            except json.JSONDecodeError as e:
                print(f"Gagal menguraikan JSON: {e}")
        else:
            # Proses pesan biner (data audio).
            print(f"Pesan biner diterima, ukuran: {len(message)} byte")
            with open(self.output_file, "ab") as f:
                f.write(message)
            print(f"Data audio telah ditulis ke file lokal {self.output_file}")

    def on_error(self, ws, error):
        """Callback pada kesalahan."""
        print(f"Kesalahan WebSocket: {error}")

    def on_close(self, ws, close_status_code, close_msg):
        """Callback pada penutupan."""
        print(f"WebSocket ditutup: {close_msg} ({close_status_code})")

    def send_continue_task(self, text):
        """Mengirim perintah continue-task dengan teks yang akan disintesis."""
        cmd = {
            "header": {
                "action": "continue-task",
                "task_id": self.task_id,
                "streaming": "duplex"
            },
            "payload": {
                "input": {
                    "text": text
                }
            }
        }

        self.ws.send(json.dumps(cmd))
        print(f"Perintah continue-task dikirim, konten teks: {text}")

    def send_finish_task(self):
        """Mengirim perintah finish-task untuk mengakhiri tugas sintesis suara."""
        cmd = {
            "header": {
                "action": "finish-task",
                "task_id": self.task_id,
                "streaming": "duplex"
            },
            "payload": {
                "input": {}
            }
        }

        self.ws.send(json.dumps(cmd))
        print("Perintah finish-task dikirim")

    def close(self, ws):
        """Menutup koneksi secara aktif."""
        if ws and ws.sock and ws.sock.connected:
            ws.close()
            print("Koneksi ditutup secara aktif")

    def run(self):
        """Memulai klien WebSocket."""
        # Atur header permintaan (otentikasi).
        header = {
            "Authorization": f"bearer {self.api_key}",
            "X-DashScope-DataInspection": "enable"
        }

        # Buat instans WebSocketApp.
        self.ws = websocket.WebSocketApp(
            self.uri,
            header=header,
            on_open=self.on_open,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close
        )

        print("Mendengarkan pesan WebSocket...")
        self.ws.run_forever()  # Mulai pendengar koneksi persisten.


# Contoh penggunaan
if __name__ == "__main__":
    # Kunci API untuk wilayah Singapura dan Beijing berbeda. Untuk mendapatkan kunci API, lihat https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    # Jika Anda belum mengonfigurasi variabel lingkungan, ganti baris berikut dengan: API_KEY = "sk-xxx"
    API_KEY = os.environ.get("DASHSCOPE_API_KEY")
    # URL berikut untuk wilayah Singapura. Jika Anda menggunakan model dari wilayah Beijing, ganti URL dengan: wss://dashscope.aliyuncs.com/api-ws/v1/inference/
    SERVER_URI = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/"

    client = TTSClient(API_KEY, SERVER_URI)
    client.run()