We use essential cookies for the website to function, as well as analytics cookies for analyzing and creating statistics of the website performance. To agree to the use of analytics cookies, click "Accept All". You can manage your preferences at any time by clicking "Cookie Settings" on the footer. More Information.

Cookie Settings
Only Essential Cookies
Accept All
MaterialsConsole

HarmonyOS

输入关键字搜索
HMS Core
AppGallery Connect
HUAWEI HiAI
CTRL+K
GuidesAICore Speech KitText-to-Speech

Text-to-Speech

Last updated: 2026-09-23 06:47
Content overview
Expand

Core Speech Kit can synthesize Chinese and English text (simplified Chinese, Traditional Chinese, digits, and English) with a maximum of 10,000 characters into speech and output the speech using a selected timbre.

You can set playback policies related to words, digits, mute pause, and Chinese character pronunciation.

Use Cases

A system app with the text-to-speech (TTS) function integrated can offer voice narration capabilities for users with visual impairments or in scenarios where reading is not convenient, even when the device (mobile phone, tablet, and others) is disconnected from the Internet.

Constraints

Expand
AI Capability Constraint
Text-to-speech

- Supported languages: Chinese and English (Simplified Chinese, Traditional Chinese, and English within a Chinese context).

- Supported timbre types: Ling Xiaoshan female voice, Laura female voice for English (US), and Ling Feizhe male voice.

- Text length: no more than 10,000 characters

Development Procedure

  1. Add the TTS-related classes to the project.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. import { textToSpeech } from '@kit.CoreSpeechKit';
    2. import { BusinessError } from '@kit.BasicServicesKit';

  2. Call the createEngine API to create a TextToSpeechEngine instance.

    The createEngine API can be called in two ways. The following uses one way as an example. For details about the other way, please refer to the API Reference.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. let ttsEngine: textToSpeech.TextToSpeechEngine;
    2. 

    3. // Set the parameters for creating an engine.
    4. let extraParam: Record<string, Object> = {'style': 'interaction-broadcast', 'locate': 'CN', 'name': 'EngineName'};
    5. let initParamsInfo: textToSpeech.CreateEngineParams = {
    6.   language: 'zh-CN',
    7.   person: 0,
    8.   online: 1,
    9.   extraParams: extraParam
    10. };
    11. 

    12. // Call the createEngine method.
    13. textToSpeech.createEngine(initParamsInfo, (err: BusinessError,
    14.                                            textToSpeechEngine: textToSpeech.TextToSpeechEngine) => {
    15.   if (!err) {
    16.     console.info('Succeeded in creating engine');
    17.     // Receive the instance for engine creation.
    18.     ttsEngine = textToSpeechEngine;
    19.   } else {
    20.     console.error(`Failed to create engine. Code: ${err.code}, message: ${err.message}.`);
    21.   }
    22. });

  3. After obtaining the TextToSpeechEngine instance, instantiate the SpeakParams and SpeakListener objects, pass the text to be synthesized and played (originalText), and call the speak API to play the text.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. // Define the callback methods for speakListener.
    2. let speakListener: textToSpeech.SpeakListener = {
    3.   // Callback triggered upon initialization of playback.
    4.   onStart(requestId: string, response: textToSpeech.StartResponse) {
    5.     console.info(`onStart, requestId: ${requestId} response: ${JSON.stringify(response)}`);
    6.   },
    7.   // Callback triggered upon completion of speech synthesis or playback.
    8.   onComplete(requestId: string, response: textToSpeech.CompleteResponse) {
    9.     console.info(`onComplete, requestId: ${requestId} response: ${JSON.stringify(response)}`);
    10.   },
    11.   // Callback triggered when the playback stops.
    12.   onStop(requestId: string, response: textToSpeech.StopResponse) {
    13.     console.info(`onStop, requestId: ${requestId} response: ${JSON.stringify(response)}`);
    14.   },
    15.   // Callback triggered when the audio stream is returned.
    16.   onData(requestId: string, audio: ArrayBuffer, response: textToSpeech.SynthesisResponse) {
    17.     console.info(`onData, requestId: ${requestId} sequence: ${JSON.stringify(response)} audio: ${JSON.stringify(audio)}`);
    18.   },
    19.   // Callback triggered when an error occurs.
    20.   onError(requestId: string, errorCode: number, errorMessage: string) {
    21.     console.error(`onError, requestId: ${requestId} errorCode: ${errorCode} errorMessage: ${errorMessage}`);
    22.   }
    23. };
    24. // Set callback methods.
    25. ttsEngine.setListener(speakListener);
    26. // Set the content to play back.
    27. let originalText: string = 'Hello HarmonyOS';
    28. // Set playback parameters.
    29. let extraParam: Record<string, Object> = {
    30.  'queueMode': 0,
    31.  'speed': 1,
    32.  'volume': 2,
    33.  'pitch': 1,
    34.  'languageContext': 'zh-CN',
    35.  'audioType': 'pcm',
    36.  'soundChannel': 3,
    37.  'playType': 1
    38. };
    39. let speakParams: textToSpeech.SpeakParams = {
    40.   requestId: '123456', // requestId can be used only once in the same instance. Do not set it repeatedly.
    41.   extraParams: extraParam
    42. };
    43. // Call the playback method.
    44. // You can modify speakParams to set playback policies.
    45. try {
    46.   ttsEngine.speak(originalText, speakParams);
    47. } catch (err) {
    48.   console.error(`error code: ${err.code}, message: ${err.message}.`);
    49. }

  4. (Optional) To stop synthesis and playback, call stop.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. ttsEngine.stop();

  5. (Optional) To check whether the TTS service is busy, call isBusy.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. ttsEngine.isBusy();

  6. (Optional) To query the timbre information of supported languages, call listVoices.

    The listVoices API can be called in two ways. The following uses one way as an example. For details about the other way, please refer to the API Reference.

    Collapse
    Word wrap
    Dark theme
    Copy code
    1. // Declare and initialize the string voiceInfo in the component.
    2. @State voiceInfo: string = '';
    3. 

    4. // Set query parameters.
    5. let voicesQuery: textToSpeech.VoiceQuery = {
    6.   requestId: '12345678', // requestId can be used only once in the same instance. Do not set it repeatedly.
    7.   online: 1
    8. };
    9. // Call listVoices. The result will be returned through a callback.
    10. ttsEngine.listVoices(voicesQuery, (err: BusinessError, voiceInfo: textToSpeech.VoiceInfo[]) => {
    11.   if (!err) {
    12.     // Receive information such as the supported languages and timbres.
    13.     this.voiceInfo = JSON.stringify(voiceInfo);
    14.     console.info(`Succeeded in listing voices, voiceInfo is ${this.voiceInfo}`);
    15.   } else {
    16.     console.error(`Failed to list voices. Code: ${err.code}, message: ${err.message}`);
    17.   }
    18. });

Setting a playback policy

In different scenarios, playback policies automatically selected by the model may not meet the actual requirement. This section describes how to proactively set playback policies.

NOTE

Valid values are provided in the relevant sections below. If the input value is outside its range, the playback may not work as expected, and an incorrect playback result will be generated.

Setting a word playback mode

Text format: [hN] (N=0/1/2)

The values of N are described as follows.

Expand
Value Description
0 Intelligently determines the word playback mode. The default value is 0.
1 Plays the content in letter-by-letter mode.
2 Plays the content as a word.

Text example:

Collapse
Word wrap
Dark theme
Copy code
  1. 'hello[h1] world'

The word "hello" is pronounced as a word, and the word "world" and subsequent words are pronounced letter by letter.

Setting a digit playback policy

Format: [nN] (N=0/1/2)

The values of N are described as follows.

Expand
Value Description
0 Intelligently determines the digit playback policy. The default value is 0.
1 Plays the content in digit-by-digit mode.
2 Plays the content as a number. Numbers exceeding 18 digits are not supported and will be read out digit by digit automatically.

Text example:

Collapse
Word wrap
Dark theme
Copy code
  1. '[n2]123[n1]456[n0]'

In the example, 123 is played as a number, 456 is played digit by digit, and how the digits in the following text are played is automatically determined.

Inserting a mute pause

Format: [pN]

Description: N is an unsigned integer in the unit of ms.

Text example:

Collapse
Word wrap
Dark theme
Copy code
  1. 'Hello[p500]Celia'

When this sentence is played, a 500 ms mute pause is inserted after "Hello".

Specifying pronunciation of Chinese characters

The tone of a Chinese character is represented by a digit from 1 to 5, indicating five tones: level tone, rising tone, falling-rising tone, falling tone, and light tone.

Format: [=MN]

Description: M indicates pinyin, and N indicates tone.

The values of N are described as follows.

Expand
Value Description
1 Level tone
2 Yang Ping
3 Falling-rising tone
4 Falling tone
5 Light tone

Text example:

Collapse
Word wrap
Dark theme
Copy code
  1. 'Text to be played[=**zhuo2**]'

The text will be played in "zhuó" (rising tone).

Development example

Implement a button that supports text-to-speech conversion and playback.

Index.ets

Collapse
Word wrap
Dark theme
Copy code
  1. import { textToSpeech } from '@kit.CoreSpeechKit';
  2. import { BusinessError } from '@kit.BasicServicesKit';
  3. import { PromptAction, UIContext } from '@kit.ArkUI';
  4. import { TreeMap } from '@kit.ArkTS';
  5. import { fileIo } from '@kit.CoreFileKit';
  6. import PcmPlayer from './PcmPlayer';
  7. import { audio } from '@kit.AudioKit';
  8. import { Context } from '@kit.AbilityKit';
  9. 

  10. const TAG: string = 'TtsDemo';
  11. let ttsEngine: textToSpeech.TextToSpeechEngine;
  12. let bufferLength: number = 0;
  13. let engineCreated: boolean = false;
  14. 

  15. // Define a function to concatenate ArrayBuffers.
  16. function concatenateArrayBuffers(buffers: ArrayBuffer[]): ArrayBuffer {
  17.   const totalLength = buffers.reduce((sum, buffer) => sum + buffer.byteLength, 0);
  18.   const concatenatedBuffer = new ArrayBuffer(totalLength);
  19.   let offset = 0;
  20.   for (const buffer of buffers) {
  21.     const uint8Array = new Uint8Array(buffer);
  22.     new Uint8Array(concatenatedBuffer, offset, uint8Array.length).set(uint8Array);
  23.     offset += uint8Array.length;
  24.   }
  25.   return concatenatedBuffer;
  26. }
  27. 

  28. @Entry
  29. @Component
  30. struct Index {
  31.   @State createCount: number = 0;
  32.   // Set the content to play back.
  33.     @State originalText: string = '\n\t\t *Text to be converted into speech* \n\t\t' + '*Text to be converted into speech* \n\t\t';
  34.   @State uiContext: UIContext = this.getUIContext();
  35.   @State promptAction: PromptAction = this.uiContext.getPromptAction();
  36.   private pcmData: TreeMap<number, Uint8Array> = new TreeMap();
  37.   private pcmPlayer: PcmPlayer = new PcmPlayer();
  38. 

  39.   build() {
  40.     Column() {
  41.       Scroll() {
  42.         Column() {
  43.           TextArea({ placeholder: 'Please enter tts original text', text: `${this.originalText}` })
  44.             .margin(20)
  45.             .focusable(false)
  46.             .border({ width: 5, color: 0x317AE7, radius: 10, style: BorderStyle.Dotted })
  47.             .onChange((value: string) => {
  48.               this.originalText = value;
  49.               console.info(TAG, 'original text: ' + this.originalText);
  50.             })
  51. 

  52.           Button() {
  53.             Text('CreateEngine')
  54.               .fontColor(Color.White)
  55.               .fontSize(20)
  56.           }
  57.           .type(ButtonType.Capsule)
  58.           .backgroundColor('#0x317AE7')
  59.           .width('80%')
  60.           .height(50)
  61.           .margin(10)
  62.           .onClick(() => {
  63.             engineCreated = true;
  64.             this.createCount++;
  65.             console.info(`createByCallback: createCount:${this.createCount}`);
  66.             this.createByCallback();
  67.             try {
  68.               this.promptAction.showToast({
  69.                 message: 'CreateEngine success!',
  70.                 duration: 2000
  71.               });
  72.             } catch (error) {
  73.               let message = (error as BusinessError).message;
  74.               let code = (error as BusinessError).code;
  75.               console.error(`showToast args error code is ${code}, message is ${message}`);
  76.             }
  77.           })
  78. 

  79.           Button() {
  80.             Text('speak')
  81.               .fontColor(Color.White)
  82.               .fontSize(20)
  83.           }
  84.           .type(ButtonType.Capsule)
  85.           .backgroundColor('#0x317AE7')
  86.           .width('80%')
  87.           .height(50)
  88.           .margin(10)
  89.           .onClick(() => {
  90.             if (engineCreated) {
  91.               try {
  92.                 this.speak();
  93.                 try {
  94.                   this.promptAction.showToast({
  95.                     message: 'start speaking',
  96.                     duration: 2000
  97.                   });
  98.                 } catch (error) {
  99.                   let message = (error as BusinessError).message;
  100.                   let code = (error as BusinessError).code;
  101.                   console.error(`showToast args error code is ${code}, message is ${message}`);
  102.                 }
  103.               } catch (err) {
  104.                 try {
  105.                   this.promptAction.showToast({
  106.                     message: 'start speaking failed',
  107.                     duration: 2000
  108.                   });
  109.                 } catch (error) {
  110.                   let message = (error as BusinessError).message;
  111.                   let code = (error as BusinessError).code;
  112.                   console.error(`showToast args error code is ${code}, message is ${message}`);
  113.                 }
  114.               }
  115.             } else {
  116.               try {
  117.                 this.promptAction.showToast({
  118.                   message: 'The engine has not been created',
  119.                   duration: 2000
  120.                 });
  121.               } catch (error) {
  122.                 let message = (error as BusinessError).message;
  123.                 let code = (error as BusinessError).code;
  124.                 console.error(`showToast args error code is ${code}, message is ${message}`);
  125.               }
  126.             }
  127.           })
  128. 

  129.           Button() {
  130.             Text('speakOnData')
  131.               .fontColor(Color.White)
  132.               .fontSize(20)
  133.           }
  134.           .type(ButtonType.Capsule)
  135.           .backgroundColor('#0x317AE7')
  136.           .width('80%')
  137.           .height(50)
  138.           .margin(10)
  139.           .onClick(() => {
  140.             if (engineCreated) {
  141.               try {
  142.                 void this.speakOnData();
  143.                 try {
  144.                   this.promptAction.showToast({
  145.                     message: 'start speakOnData',
  146.                     duration: 2000
  147.                   });
  148.                 } catch (error) {
  149.                   let message = (error as BusinessError).message;
  150.                   let code = (error as BusinessError).code;
  151.                   console.error(`showToast args error code is ${code}, message is ${message}`);
  152.                 }
  153.               } catch (err) {
  154.                 try {
  155.                   this.promptAction.showToast({
  156.                     message: 'start speakOnData failed',
  157.                     duration: 2000
  158.                   });
  159.                 } catch (error) {
  160.                   let message = (error as BusinessError).message;
  161.                   let code = (error as BusinessError).code;
  162.                   console.error(`showToast args error code is ${code}, message is ${message}`);
  163.                 }
  164.               }
  165.             } else {
  166.               try {
  167.                 this.promptAction.showToast({
  168.                   message: 'The engine has not been created',
  169.                   duration: 2000
  170.                 });
  171.               } catch (error) {
  172.                 let message = (error as BusinessError).message;
  173.                 let code = (error as BusinessError).code;
  174.                 console.error(`showToast args error code is ${code}, message is ${message}`);
  175.               }
  176.             }
  177.           })
  178. 

  179.           Button() {
  180.             Text('stop')
  181.               .fontColor(Color.White)
  182.               .fontSize(20)
  183.           }
  184.           .type(ButtonType.Capsule)
  185.           .backgroundColor('#0x317AE7')
  186.           .width('80%')
  187.           .height(50)
  188.           .margin(10)
  189.           .onClick(() => {
  190.             try {
  191.               let isBusy: boolean = ttsEngine.isBusy();
  192.               let isPlaying: boolean = this.pcmPlayer.isPlaying();
  193.               if (isBusy) {
  194.                 ttsEngine.stop();
  195.               }
  196.               if (isPlaying) {
  197.                 this.pcmPlayer.stop();
  198.               }
  199.               try {
  200.                 this.promptAction.showToast({
  201.                   message: 'stop!',
  202.                   duration: 2000
  203.                 });
  204.               } catch (error) {
  205.                 let message = (error as BusinessError).message;
  206.                 let code = (error as BusinessError).code;
  207.                 console.error(`showToast args error code is ${code}, message is ${message}`);
  208.               }
  209.             } catch (err) {
  210.               try {
  211.                 this.promptAction.showToast({
  212.                   message: 'stop failed',
  213.                   duration: 2000
  214.                 });
  215.               } catch (error) {
  216.                 let message = (error as BusinessError).message;
  217.                 let code = (error as BusinessError).code;
  218.                 console.error(`showToast args error code is ${code}, message is ${message}`);
  219.               }
  220.             }
  221.           })
  222. 

  223.           Button() {
  224.             Text('isBusy')
  225.               .fontColor(Color.White)
  226.               .fontSize(20)
  227.           }
  228.           .type(ButtonType.Capsule)
  229.           .backgroundColor('#0x317AE7')
  230.           .width('80%')
  231.           .height(50)
  232.           .margin(10)
  233.           .onClick(() => {
  234.             try {
  235.               let isBusy: boolean = ttsEngine.isBusy();
  236.               let isPlaying: boolean = this.pcmPlayer.isPlaying();
  237.               console.info('isBusy :' + isBusy);
  238.               console.info('isPlaying :' + isPlaying);
  239.               try {
  240.                 this.promptAction.showToast({
  241.                   message: 'speak isBusy :' + isBusy + '\nspeakOnData isBusy :' + isPlaying,
  242.                   duration: 2000
  243.                 });
  244.               } catch (error) {
  245.                 let message = (error as BusinessError).message;
  246.                 let code = (error as BusinessError).code;
  247.                 console.error(`showToast args error code is ${code}, message is ${message}`);
  248.               }
  249.             } catch (err) {
  250.               try {
  251.                 this.promptAction.showToast({
  252.                   message: 'isBusy failed',
  253.                   duration: 2000
  254.                 });
  255.               } catch (error) {
  256.                 let message = (error as BusinessError).message;
  257.                 let code = (error as BusinessError).code;
  258.                 console.error(`showToast args error code is ${code}, message is ${message}`);
  259.               }
  260.             }
  261.           })
  262. 

  263.           Button() {
  264.             Text('shutdown')
  265.               .fontColor(Color.White)
  266.               .fontSize(20)
  267.           }
  268.           .type(ButtonType.Capsule)
  269.           .backgroundColor('#0x317AA7')
  270.           .width('80%')
  271.           .height(50)
  272.           .margin(10)
  273.           .onClick(() => {
  274.             try {
  275.               this.pcmPlayer.release();
  276.               ttsEngine.shutdown();
  277.               engineCreated = false;
  278.               try {
  279.                 this.promptAction.showToast({
  280.                   message: 'shutdown success!',
  281.                   duration: 2000
  282.                 });
  283.               } catch (error) {
  284.                 let message = (error as BusinessError).message;
  285.                 let code = (error as BusinessError).code;
  286.                 console.error(`showToast args error code is ${code}, message is ${message}`);
  287.               }
  288.             } catch (err) {
  289.               try {
  290.                 this.promptAction.showToast({
  291.                   message: 'shutdown failed',
  292.                   duration: 2000
  293.                 });
  294.               } catch (error) {
  295.                 let message = (error as BusinessError).message;
  296.                 let code = (error as BusinessError).code;
  297.                 console.error(`showToast args error code is ${code}, message is ${message}`);
  298.               }
  299.             }
  300.           })
  301. 

  302.         }
  303.         .layoutWeight(1)
  304.       }
  305.       .width('100%')
  306.       .height('100%')
  307. 

  308.     }
  309.   }
  310. 

  311.   // Create an engine. The result will be returned through a callback.
  312.   // Error code 1002300005 indicating engine creation failure is returned if the engine does not exist, engine resources do not exist, or the initialization times out.
  313.   private createByCallback() {
  314.     // Set the parameters for creating an engine.
  315.     let extraParam: Record<string, Object> = { 'style': 'interaction-broadcast', 'locate': 'CN', 'name': 'EngineName' };
  316.     let initParamsInfo: textToSpeech.CreateEngineParams = {
  317.       language: 'zh-CN',
  318.       person: 0,
  319.       online: 1,
  320.       extraParams: extraParam
  321.     };
  322.     try {
  323.       // Call the createEngine method.
  324.       textToSpeech.createEngine(initParamsInfo, (err: BusinessError,
  325.                                                  textToSpeechEngine: textToSpeech.TextToSpeechEngine) => {
  326.         if (!err) {
  327.           console.info('createEngine is success');
  328.           // Receive the instance for engine creation.
  329.           ttsEngine = textToSpeechEngine;
  330.         } else {
  331.           console.error(`error code: ${err.code}, message: ${err.message}.`);
  332.         }
  333.       });
  334.     } catch (error) {
  335.       let message = (error as BusinessError).message;
  336.       let code = (error as BusinessError).code;
  337.       console.error(`createEngine failed, error code: ${code}, message: ${message}.`);
  338.     }
  339.   }
  340. 

  341.   // Call the speak method.
  342.   private speak() {
  343.     let speakListener: textToSpeech.SpeakListener = {
  344.       // Callback triggered upon initialization of playback.
  345.       onStart(requestId: string, response: textToSpeech.StartResponse) {
  346.         console.info(`onStart, requestId: ${requestId} response: ${JSON.stringify(response)}`);
  347.       },
  348.       // Callback triggered when playback is complete.
  349.       onComplete(requestId: string, response: textToSpeech.CompleteResponse) {
  350.         console.info(`onComplete, requestId: ${requestId} response: ${JSON.stringify(response)}`);
  351.       },
  352.       // Callback triggered when playback is stopped, that is, after stop is called and successfully executed.
  353.       onStop(requestId: string, response: textToSpeech.StopResponse) {
  354.         console.info(`onStop, requestId: ${requestId} response: ${JSON.stringify(response)}`);
  355.       },
  356.       // Callback triggered when the audio stream is returned.
  357.       onData(requestId: string, audio: ArrayBuffer, response: textToSpeech.SynthesisResponse) {
  358.         console.info(`onData, requestId: ${requestId} sequence: ${JSON.stringify(response)} audio: ${JSON.stringify(audio)}`);
  359.       },
  360.       // Callback triggered when an error occurs during the playback.
  361.       onError(requestId: string, errorCode: number, errorMessage: string) {
  362.         if (errorCode === 1002300007) {
  363.           engineCreated = false;
  364.         }
  365.         console.error(`onError, requestId: ${requestId} errorCode: ${errorCode} errorMessage: ${errorMessage}`);
  366.       }
  367.     };
  368.     // Set callback methods.
  369.     ttsEngine.setListener(speakListener);
  370.     // Set playback parameters.
  371.     let extraParam: Record<string, Object> = {
  372.         'queueMode': 0,
  373.         'speed': 1,
  374.         'volume': 2,
  375.         'pitch': 1,
  376.         'languageContext': 'zh-CN',
  377.         'audioType': 'pcm',
  378.         'soundChannel': 3,
  379.         'playType':1
  380.       };
  381.     let speakParams: textToSpeech.SpeakParams = {
  382.       requestId: '123456' + Date.now(), // requestId can be used only once in the same instance. Do not set it repeatedly.
  383.       extraParams: extraParam
  384.     };
  385.     // Call the speak method.
  386.     try {
  387.       ttsEngine.speak(this.originalText, speakParams);
  388.     } catch (err) {
  389.       console.error(TAG, `error code: ${err.code}, message: ${err.message}.`);
  390.     }
  391.   }
  392. 

  393.   private onStart = (utteranceId: string, response: textToSpeech.StartResponse) => {
  394.     bufferLength = 0;
  395.     // Initialize audio data mapping.
  396.     console.info(TAG, `onStart | utteranceId: ${ utteranceId }, response: ${JSON.stringify(response)}`);
  397.   }
  398. 

  399.   private onData = (utteranceId: string, audio: ArrayBuffer, response: textToSpeech.SynthesisResponse) => {
  400.     // Convert ArrayBuffer to Uint8Array.
  401.     let uint8Array: Uint8Array = new Uint8Array(audio);
  402.     this.pcmData.set(response.sequence, uint8Array);
  403.     bufferLength += 1;
  404.     let str = '';
  405.     // Alternatively, print each element using a loop.
  406.     for (let i = 0; i < uint8Array.length; i++) {
  407.       str = str + (',' + uint8Array[i]);
  408.     }
  409.     console.info(TAG, `onData | utteranceId: ${utteranceId}, sequence: ${JSON.stringify(response.sequence)}, length: ${uint8Array.length}, audio: ${JSON.stringify(str)}`);
  410.   }
  411. 

  412.   private onComplete = (utteranceId: string, response: textToSpeech.CompleteResponse) => {
  413.     let buffers: ArrayBuffer[] = new Array();
  414. 

  415.     console.info(TAG, `pcmData len: ${this.pcmData.length}`);
  416.     // Traverse the map and add each ArrayBuffer to the array.
  417.     try {
  418.       this.pcmData?.forEach((value: Uint8Array) => {
  419.         buffers.push(value.buffer.slice(0));
  420.       })
  421.     } catch (forEachErr) {
  422.       console.error(TAG, 'pcmData forEach failed:', forEachErr);
  423.     }
  424.     console.info(TAG, `buffers len: ${buffers.length}`);
  425. 

  426.     // Concatenate all ArrayBuffers in sequence.
  427.     let audioData = concatenateArrayBuffers(buffers);
  428.     console.info(TAG, `audioData len: ${audioData.byteLength}`);
  429. 

  430.     let context = this.uiContext.getHostContext() as Context;
  431.     let path = context.filesDir;
  432.     let filePath: string = `${path}/my.pcm`;
  433.     fileIo.createStream(filePath, 'w+')
  434.       .then(os => os.write(audioData).catch((e: BusinessError) => {
  435.         throw new Error(`Write failed: ${e}`)
  436.       }))
  437.       .then((): Promise<void> => {
  438.         try {
  439.           this.pcmPlayer.file = fileIo.openSync(filePath, fileIo.OpenMode.READ_ONLY);
  440.           return this.pcmPlayer.prepare(audio.AudioSamplingRate.SAMPLE_RATE_16000);
  441.         } catch (e) {
  442.           throw new Error(`Open failed: ${e}`)
  443.         }
  444.       })
  445.       .then(() => this.pcmPlayer.play(audioData))
  446.       .catch((err: BusinessError) => console.error(TAG, `Error: ${err}`));
  447. 

  448.     console.info(TAG, `onComplete | utteranceId: ${utteranceId}, response: ${JSON.stringify(response)}`);
  449.   }
  450. 

  451.   // Call the speakOnData method.
  452.   // Error code 1002300007 indicating synthesis and playback failure is returned if the speak method is called before engine initialization.
  453.   private speakOnData() {
  454.     // Set playback parameters.
  455.     let extraParam: Record<string, Object> = {
  456.         'queueMode': 0,
  457.         'speed': 1.2,
  458.         'volume': 2,
  459.         'pitch': 1,
  460.         'languageContext': 'zh-CN',
  461.         'audioType': 'pcm',
  462.         'soundChannel': 1,
  463.         'playType':0
  464.       };
  465.     let speakParams: textToSpeech.SpeakParams = {
  466.       requestId: '1234567' + Date.now(),
  467.       extraParams: extraParam
  468.     };
  469. 

  470.     try {
  471.       // Create a callback object.
  472.       let speakListener: textToSpeech.SpeakListener = {
  473.         // Callback when the recognition is successful.
  474.         onStart: this.onStart,
  475.         // Callback upon recognition completion.
  476.         onComplete: this.onComplete,
  477.         // Callback triggered when the playback stops.
  478.         onStop(utteranceId: string, response: textToSpeech.StopResponse) {
  479.           console.info('speakListener onStop: ' + ' utteranceId: ' + utteranceId + ' response: ' + JSON.stringify(response));
  480.         },
  481.         // Callback triggered when the audio stream is returned.
  482.         onData: this.onData,
  483.         // Callback triggered when an error occurs.
  484.         onError(utteranceId: string, errorCode: number, errorMessage: string) {
  485.           if (errorCode === 1002300007) {
  486.             engineCreated = false;
  487.           }
  488.           console.error('speakListener onError: ' + ' utteranceId: ' + utteranceId + ' errorCode: ' + errorCode + ' errorMessage: ' + errorMessage);
  489.         }
  490.       };
  491.       // Set callback methods.
  492.       ttsEngine.setListener(speakListener);
  493.       try {
  494.         console.info(`speakListener before speak`);
  495.         // Call the speak method.
  496.         for (let i = 0; i < 1; i++) {
  497.           ttsEngine?.speak(this.originalText, speakParams);
  498.         }
  499.         console.info(`speakListener after speak`)
  500.       } catch (error) {
  501.         let message = (error as BusinessError).message;
  502.         let code = (error as BusinessError).code;
  503.         console.error(`speakListener speak failed, error code: ${code}, message: ${message}.`);
  504.       }
  505.     } catch (error) {
  506.       let message = (error as BusinessError).message;
  507.       let code = (error as BusinessError).code;
  508.       console.error(`speakListener setListener failed, error code: ${code}, message: ${message}.`);
  509.     }
  510.   }
  511. }

PcmPlayer.ets

Collapse
Word wrap
Dark theme
Copy code
  1. import { audio } from '@kit.AudioKit';
  2. import { fileIo } from '@kit.CoreFileKit';
  3. 

  4. const TAG = 'PCM_audio';
  5. 

  6. class Options {
  7.   offset?: number;
  8.   length?: number;
  9. }
  10. 

  11. export default class PcmPlayer {
  12. 

  13.   public file: fileIo.File | undefined;
  14.   private writeDataCallback = (buffer: ArrayBuffer) => {
  15.     let options: Options = {
  16.       offset: this.bufferSize,
  17.       length: buffer.byteLength
  18.     };
  19. 

  20.     try {
  21.       fileIo.readSync(this.file?.fd, buffer, options);
  22.       this.bufferSize += buffer.byteLength;
  23.       if (this.audioDataSize < this.bufferSize) {
  24.         this.renderModel?.off('writeData');
  25.         void this.stop()
  26.       }
  27.       console.info(TAG, 'reading file success');
  28.       // The system determines that the buffer is valid and plays the data normally.
  29.       return audio.AudioDataCallbackResult.VALID;
  30.     } catch (error) {
  31.       console.error(TAG, `Reading file failed, error code: ${error.code}, message: ${error.message}.`);
  32.       // The system determines that the buffer is invalid and does not play the data.
  33.       return audio.AudioDataCallbackResult.INVALID;
  34.     }
  35.   };
  36.   /**
  37.    * Cache size
  38.    */
  39.   private bufferSize: number = 0;
  40.   /**
  41.    * Total audio data size.
  42.    */
  43.   private audioDataSize: number = 0;
  44.   /**
  45.    *Player
  46.    */
  47.   private renderModel: audio.AudioRenderer | null = null;
  48.   /**
  49.    * Reading status
  50.    */
  51.   private audioStreamInfo: audio.AudioStreamInfo = {
  52.     samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_16000, // Sampling rate.
  53.     channels: audio.AudioChannel.CHANNEL_1, // Channel.
  54.     sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE, // Sampling format.
  55.     encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW // Encoding format.
  56.   };
  57.   private audioRendererInfo: audio.AudioRendererInfo = {
  58.     usage: audio.StreamUsage.STREAM_USAGE_ACCESSIBILITY, // Audio stream usage type.
  59.     rendererFlags: 0 // AudioRenderer flag.
  60.   };
  61.   private audioRendererOptions: audio.AudioRendererOptions = {
  62.     streamInfo: this.audioStreamInfo,
  63.     rendererInfo: this.audioRendererInfo
  64.   };
  65. 

  66.   public async prepare(sampleRate: number) {
  67.     this.audioRendererOptions.streamInfo.samplingRate = sampleRate;
  68.     this.audioRendererOptions.rendererInfo.usage = audio.StreamUsage.STREAM_USAGE_MUSIC;
  69.     if (this.renderModel != null) {
  70.       await this.renderModel.release();
  71.     }
  72.     let renderModel = await audio.createAudioRenderer(this.audioRendererOptions);
  73.     if (!renderModel) {
  74.       console.error(TAG, `failed to create audio renderer`);
  75.     }
  76.     console.info(TAG, 'creating AudioRenderer success');
  77.     this.renderModel = renderModel;
  78.     this.bufferSize = await this.renderModel.getBufferSize();
  79.   }
  80. 

  81.   public async play(data: ArrayBuffer): Promise<number> {
  82.     this.audioDataSize = data.byteLength
  83.     if (this.renderModel != null) {
  84.       try {
  85.         this.renderModel.on('writeData', this.writeDataCallback);
  86.       } catch (err) {
  87.         console.error(`error code: ${err.code}, message: ${err.message}.`);
  88.       }
  89.       // Start rendering.
  90.       await this.renderModel.start();
  91.       console.info(TAG, 'start AudioRenderer success');
  92.     }
  93.     return -1;
  94.   }
  95. 

  96.   public async stop() {
  97.     console.info(TAG, 'Renderer begin stop');
  98.     if (this.renderModel == null) {
  99.       return;
  100.     }
  101. 

  102.     // Rendering can be stopped only when the AudioRenderer is in the running or paused state.
  103.     if (this.renderModel.state !== audio.AudioState.STATE_RUNNING
  104.       && this.renderModel.state !== audio.AudioState.STATE_PAUSED) {
  105.       console.error(TAG, 'Renderer is not running or paused');
  106.       return;
  107.     }
  108.     await this.renderModel.stop(); // Stop rendering.
  109.     console.info(TAG, 'Renderer stopped');
  110.   }
  111. 

  112.   public async release() {
  113.     // The AudioRenderer can be released only when it is not in the released state.
  114.     if (this.renderModel != null) {
  115.       if (this.renderModel.state === audio.AudioState.STATE_RELEASED) {
  116.         console.error(TAG, 'Renderer already released');
  117.         return;
  118.       }
  119.       await this.renderModel.release(); // Release the instance.
  120.       this.renderModel = null;
  121.       console.info(TAG, 'Renderer released');
  122.     }
  123.   }
  124. 

  125.   /**
  126.    * Check the current rendering status.
  127.    *
  128.    * @returns **true** if the rendering is running; **false** otherwise.
  129.    */
  130.   public isPlaying() {
  131.     if (this.renderModel != null) {
  132.       console.info(TAG, 'player.state:' + this.renderModel.state);
  133.       return this.renderModel.state == audio.AudioState.STATE_RUNNING;
  134.     } else {
  135.       return false;
  136.     }
  137.   }
  138. 

  139.   /**
  140.    * Obtain the current rendering status.
  141.    */
  142.   public getRenderState(): number {
  143.     if (this.renderModel != null) {
  144.       console.info(TAG, 'player.state:' + this.renderModel.state);
  145.       return this.renderModel.state;
  146.     } else {
  147.       return audio.AudioState.STATE_INVALID;
  148.     }
  149.   }
  150. 

  151.   /**
  152.    * Obtain the minimum buffer size required by the audio renderer.
  153.    */
  154.   public getBufferSize(): number {
  155.     return this.bufferSize;
  156.   }
  157. }
About This Kit
Speech Recognition
English
©2026 HUAWEI Developers. All rights reserved.
Terms of Use
Statement About HUAWEI Developers and Privacy
Cookies
Cookie Settings
Open-Source Software Notice
Search in Guides
Enter a keyword.