Alibaba Cloud Model Studio:Fun-ASR-Realtime HarmonyOS SDK

Découvrez les paramètres, les interfaces, les rappels et l'utilisation du SDK HarmonyOS pour Fun-ASR-Realtime.

Démarrage rapide

1. Obtenez une clé API. Ne codez pas en dur une clé à longue durée de vie dans l'application cliente. Il est recommandé que le serveur applicatif obtienne une clé API temporaire et l'envoie au client.

2. Téléchargez le dernier SDK. Extrayez-le, copiez entry/libs/neonui.har dans le répertoire entry/libs de l'application et ajoutez la dépendance à entry/oh-package.json5 :

   {
     "dependencies": {
       "neonui": "file:libs/neonui.har"
     }
   }
   

   Pour une intégration HarmonyOS C++, utilisez les bibliothèques partagées de native/libs et les fichiers d'en-tête de native/include.

3. Déclarez les autorisations réseau et microphone dans module.json5, puis demandez l'autorisation microphone à l'exécution. reason_internet et reason_microphone sont des exemples de noms de ressources. Définissez les descriptions correspondantes dans les ressources de l'application.

   "requestPermissions": [
     {
       "name": "ohos.permission.INTERNET",
       "reason": "$string:reason_internet",
       "usedScene": { "abilities": ["EntryAbility"], "when": "always" }
     },
     {
       "name": "ohos.permission.MICROPHONE",
       "reason": "$string:reason_microphone",
       "usedScene": { "abilities": ["EntryAbility"], "when": "always" }
     }
   ]
   

4. Ouvrez le projet d'exemple du SDK dans DevEco Studio. La page d'exemple est entry/src/main/ets/pages/dashscope/DashFunAsrSpeechTranscriberPage.ets. Configurez une clé API et exécutez le projet.

Séquence d'appel

1. Créez une instance de NativeNui(Constants.ModeType.MODE_DIALOG).
2. Appelez initialize pour initialiser le SDK et configurer la connexion et le contrôle.
3. Appelez setParams pour configurer le modèle et les paramètres de reconnaissance.
4. Appelez startDialog pour démarrer la reconnaissance.
5. Dans onNuiAudioStateChanged, démarrez, suspendez ou fermez le périphérique d'enregistrement selon l'état audio.
6. Fournissez continuellement les données dans onNuiNeedAudioData. Si l'envoi actif est activé, appelez plutôt updateAudio.
7. Récupérez les résultats et l'état de la tâche dans onNuiEventCallback.
8. Appelez stopDialog et attendez EVENT_TRANSCRIBER_COMPLETE.
9. Lorsque la reconnaissance n'est plus nécessaire, appelez release pour libérer les ressources.

Paramètres de requête

Paramètres de connexion et de contrôle

Passez une chaîne JSON à l'argument parameters de initialize.

{
  "url": "wss://dashscope.aliyuncs.com/api-ws/v1/inference",
  "device_id": "my_device_id",
  "service_mode": "1",
  "audio_update_manually": "false"
}

Paramètre	Type	Obligatoire	Description
url	string	Oui	Points de terminaison du service : Point de terminaison public : wss://dashscope.aliyuncs.com/api-ws/v1/inference Point de terminaison de l’espace de travail à Pékin : wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference Point de terminaison de l’espace de travail à Singapour : wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference Remplacez {WorkspaceId} par votre ID d’espace de travail.
service_mode	string	Oui	Mode d'exécution. Pour la reconnaissance en temps réel, définissez-le sur "1", soit Constants.ModeFullCloud.
device_id	string	Oui	Un identifiant unique de l'utilisateur final, tel qu'un ID d'utilisateur dans l'application ou un ID d'appareil généré par le client. Il est principalement utilisé pour le suivi des journaux et le dépannage.
apikey	string	Non	Clé API. Vous pouvez la passer à l'initialisation. Il est recommandé de passer une clé temporaire dans dialog_params de startDialog.
audio_update_manually	string	Non	Active ou non l'envoi actif d'audio. Par défaut : "false". Avec "true", appelez updateAudio ; avec "false", le SDK récupère l'audio via onNuiNeedAudioData. Si la valeur est "true" et que le SDK prend en charge l'AEC ou la VAD sur l'appareil, ces capacités sont activées par défaut.
workspace	string	Non	Répertoire des ressources sur l'appareil. Obligatoire si audio_update_manually vaut "true" et si le traitement local, tel que l'AEC ou la VAD, est activé.
debug_path	string	Non	Répertoire des journaux. Obligatoire si save_log vaut true. Le SDK conserve au maximum deux fichiers journaux.
save_wav	string	Non	Enregistre ou non l'audio de débogage. Par défaut : "false". Les fichiers sont stockés dans debug_path. Avec "true", définissez aussi debug_path et passez true à save_log dans initialize.
save_wav_by_id	string	Non	Lorsque save_wav est activé, indique s'il faut nommer les fichiers audio avec task_id pour faciliter leur recherche. Par défaut : "false".
max_log_file_size	number	Non	Taille maximale d'un fichier journal en octets. Par défaut : 104857600 (100 MiB). Ne prend effet que si save_log vaut true.
log_track_level	number	Non	Niveau de filtrage des journaux de onNuiLogTrackCallback. Par défaut : 2. Valeurs : 0 (VERBOSE), 1 (DEBUG), 2 (INFO), 3 (WARNING), 4 (ERROR), 5 (NONE). Un journal n'est renvoyé que si son niveau est supérieur ou égal à log_track_level et au level de initialize. Avec 2 et 3, seuls WARNING et les niveaux supérieurs sont renvoyés.
enable_reconnection	string	Non	Active ou non la reconnexion et la reprise de transmission après une interruption réseau. Par défaut : "false".
aec_params	object	Non	Paramètres AEC sur l'appareil. Utilisés uniquement si audio_update_manually vaut "true".
aec_params.enable_aec	boolean	Non	Active ou non l'AEC sur l'appareil. Activé par défaut si la version du SDK le prend en charge.
aec_params.save_audio	boolean	Non	Enregistre ou non l'audio traité par l'AEC. Activé par défaut si save_wav est activé et debug_path défini.
aec_params.enable_aec_data_callback	boolean	Non	Renvoie ou non les données traitées par l'AEC via l'événement EVENT_AEC_DATA de onNuiAssistEventCallback. Par défaut : false.
vad_params	object	Non	Paramètres VAD sur l'appareil. Utilisés uniquement si audio_update_manually vaut "true".
vad_params.enable_vad	boolean	Non	Active ou non la VAD sur l'appareil. Activée par défaut si la version du SDK la prend en charge.
vad_params.save_audio	boolean	Non	Enregistre ou non l'audio traité par la VAD. Activé par défaut si save_wav est activé et debug_path défini.
audio_config	object	Non	Paramètres de capture audio lorsque le SDK récupère les données. Utilisés uniquement si audio_update_manually vaut "false".
audio_config.mic.enable_volume_calculation	boolean	Non	Calcule et signale ou non le volume. Par défaut : true. Désactivez cette option si les rappels de volume ne sont pas nécessaires.
audio_config.mic.volume_mode	string	Non	Mode de calcul du volume. Avec "dbfs", calcule le dBFS standard selon 20*log10(rms/32768), où la pleine échelle vaut 0 dB.

Paramètres de reconnaissance

Passez une chaîne JSON à l'argument params de setParams.

{
  "service_type": 4,
  "nls_config": {
    "model": "fun-asr-realtime",
    "sr_format": "opus",
    "sample_rate": 16000
  }
}

Paramètre	Type	Obligatoire	Description
service_type	number	Oui	Type de service vocal. Définissez sur 4, soit Constants.kServiceTypeSpeechTranscriber.
nls_config	object	Oui	Objet de configuration de la reconnaissance.
nls_config.model	string	Oui	Nom du modèle.
nls_config.sr_format	string	Oui	Format audio : pcm ou opus. Avec opus, l’application fournit toujours des données PCM, que le SDK encode en Opus.
nls_config.sample_rate	number	Oui	Fréquence d’échantillonnage en Hz. Les modèles 8 kHz exigent 8000 ; les autres acceptent toute fréquence. La fréquence de 8000 Hz n’est pas prise en charge lorsque l’AEC ou le VAD sur l’appareil est activé.
nls_config.semantic_punctuation_enabled	boolean	Non	Indique s’il faut activer la segmentation sémantique. Par défaut : false. true active la segmentation sémantique et désactive celle du VAD, pour les transcriptions de réunions privilégiant la précision. false active la segmentation VAD et désactive la segmentation sémantique, pour les interactions privilégiant une faible latence.
nls_config.max_sentence_silence	number	Non	Seuil de silence VAD en millisecondes. L’énoncé est considéré comme terminé si le silence après la parole dépasse ce seuil. Par défaut : 1300. Plage valide : [200, 6000]. Avec la segmentation sémantique, ce paramètre ne détermine pas sentence_end, mais une valeur trop faible peut affecter la reconnaissance.
nls_config.multi_threshold_mode_enabled	boolean	Non	Indique s’il faut activer le mode à seuils multiples. Par défaut : false. Ce mode évite des segments VAD trop longs. Il ne s’applique que si semantic_punctuation_enabled vaut false.
nls_config.heartbeat	boolean	Non	Indique s’il faut activer les paquets heartbeat. Par défaut : false. Si activé, l’envoi continu d’audio silencieux peut maintenir la connexion. Sinon, celle-ci expire après un certain délai. L’audio silencieux ne contient aucun signal audible dans le fichier ou le flux audio.
nls_config.vocabulary_id	string	Non	ID d’une liste de mots clés précompilée. Créez-la à l’avance. Utilisez ce champ pour un vocabulaire connu et relativement stable réutilisé entre les requêtes. Consultez Mots clés précompilés.
nls_config.language_hints	string[]	Non	Langues de l’audio. Aucune valeur par défaut ; le modèle détecte la langue si ce champ est omis. Seule la première valeur est utilisée. Pour les codes de langue, consultez le guide de reconnaissance vocale en temps réel.
nls_config.speech_noise_threshold	number	Non	Seuil VAD de distinction parole/bruit. Plage valide : [-1.0, 1.0]. Plus la valeur est proche de -1, plus le bruit risque d’être reconnu et transcrit comme parole. Plus elle est proche de 1, plus la parole risque d’être filtrée comme bruit. Ce réglage avancé peut fortement affecter la reconnaissance. Testez-le soigneusement et ajustez-le par pas de 0,1.
nls_config.special_word_filter	object	Non	Paramètres de filtrage des mots sensibles. Consultez Filtrage des mots sensibles.
nls_config.enable_connection_fast_check	boolean	Non	Indique s’il faut activer la détection rapide des interruptions réseau. Par défaut : false.

APIs

NativeNui

Importez le SDK :

import { AsrResult, Constants, INativeNuiCallback, KwsResult, NativeNui } from 'neonui';

Créer une instance

constructor(mode_type: Constants.ModeType, flag?: string)

Paramètre	Type	Description
mode_type	Constants.ModeType	Mode SDK : MODE_DIALOG pour le dialogue ou la reconnaissance, MODE_TTS pour la synthèse vocale, MODE_STREAM_INPUT_TTS pour la synthèse à entrée en streaming. Utilisez MODE_DIALOG pour la reconnaissance vocale en temps réel.
flag	string	Identifiant d’instance facultatif permettant de distinguer les journaux.

initialize

initialize(
  callback: INativeNuiCallback,
  parameters: string,
  level: number,
  save_log: boolean = false
): number

Initialise le SDK. Cette méthode peut être bloquante. Ne l'appelez pas sur le thread UI.

Paramètre	Type	Description
callback	INativeNuiCallback	Rappel des événements et des données.
parameters	string	Chaîne JSON des paramètres de connexion et de contrôle.
level	number	Niveau de journalisation SDK : LOG_LEVEL_VERBOSE (0), LOG_LEVEL_DEBUG (1), LOG_LEVEL_INFO (2), LOG_LEVEL_WARNING (3), LOG_LEVEL_ERROR (4) ou LOG_LEVEL_NONE (5).
save_log	boolean	Indique s’il faut enregistrer les journaux locaux. Par défaut : false. Si true, définissez debug_path dans parameters. Vous pouvez aussi définir max_log_file_size.

setParams

setParams(params: string): number

Définit les paramètres avant startDialog. params est une chaîne JSON contenant les paramètres de reconnaissance.

startDialog

startDialog(vad_mode: Constants.VadMode, dialog_params: string): number

Démarre la reconnaissance.

Paramètre	Type	Description
vad_mode	Constants.VadMode	Mode VAD. Utilisez Constants.VadMode.TYPE_P2T pour la reconnaissance vocale en temps réel.
dialog_params	string	Chaîne JSON permettant de renouveler une clé API temporaire expirée ou de fournir le contexte d’entrée via input_context.

Example:

{
  "apikey": "st-****",
  "input_context": [
    { "role": "user", "content": [{ "type": "input_text", "text": "Example context" }] }
  ]
}

stopDialog

stopDialog(): number

Notifie au serveur de terminer la reconnaissance et de renvoyer le résultat final. La tâche se termine à la réception de EVENT_TRANSCRIBER_COMPLETE.

cancelDialog

cancelDialog(): number

Arrête immédiatement la reconnaissance sans attendre le résultat final du serveur.

dialogAction

dialogAction(action_params: string): number

Envoie une action à l'exécution pour mettre à jour le contexte ou notifier à l'AEC les changements d'état de lecture.

Paramètre	Type	Description
action_params	string	Chaîne JSON contenant l’action.
action_params.type	string	Définissez sur "action".
action_params.command	string	Commande d’action : "context met à jour le contexte d’entrée, play_start signale à l’AEC le début de lecture de l’audio de référence et play_over" signale la fin de lecture.
action_params.context	object[]	Contexte d’entrée à utiliser lorsque command vaut "context".

Exemple de mise à jour du contexte :

{
  "type": "action",
  "command": "context",
  "context": [
    {
      "role": "user",
      "content": [
        { "text": "Example context", "type": "input_text" }
      ]
    }
  ]
}

updateAudio

updateAudio(data: ArrayBuffer, first_pack: boolean): number

Avec audio_update_manually à "true", envoie activement les données enregistrées par cette méthode plutôt que de remplir onNuiNeedAudioData.

Paramètre	Type	Description
data	ArrayBuffer	Données audio à reconnaître.
first_pack	boolean	Indique s’il s’agit du premier paquet audio. Utilisez true pour le premier paquet, puis false pour les suivants.

pushReferenceData

pushReferenceData(data: ArrayBuffer, first_pack: boolean): number

Avec audio_update_manually à "true" et l'AEC sur l'appareil activé, envoie l'audio du lecteur comme référence AEC.

Paramètre	Type	Description
data	ArrayBuffer	Données audio de référence.
first_pack	boolean	Indique s’il s’agit du premier paquet audio. Utilisez true pour le premier paquet, puis false pour les suivants.

release

release(): number

Libère toutes les ressources internes du SDK. L'instance devient inutilisable. Pour la réutiliser, appelez d'abord initialize.

GetVersion

GetVersion(): string

Renvoie la version actuelle du SDK.

refreshApikey

refreshApikey(apikey: string, url: string = ''): string

Actualise une clé API et renvoie un jeton d'authentification temporaire. Effectue un appel réseau synchrone : ne l'appelez pas sur le thread UI.

Paramètre	Type	Description
apikey	string	Clé API existante.
url	string	Point de terminaison d’authentification facultatif. Par défaut : chaîne vide, pour utiliser le point de terminaison par défaut.

INativeNuiCallback

onNuiEventCallback

onNuiEventCallback: (
  event: Constants.NuiEvent,
  resultCode: number,
  arg2: number,
  kwsResult: KwsResult,
  asrResult: AsrResult
) => void;

Reçoit les événements et les résultats de reconnaissance.

Paramètre	Type	Description
event	Constants.NuiEvent	Événement de rappel.
resultCode	number	Valide uniquement lorsque l’événement EVENT_ASR_ERROR se produit.
arg2	number	Reserved.
kwsResult	KwsResult	Résultat du mot d’activation. Ignorez ce champ pour la reconnaissance vocale en temps réel.
asrResult	AsrResult	Résultat de reconnaissance. allResponse contient la réponse JSON complète du serveur. Récupérez l’ID de tâche dans header.task_id et le texte dans payload.output.sentence.text.

Events:

Événement	Description
EVENT_TRANSCRIBER_STARTED	La tâche a démarré. header.task_id dans asrResult.allResponse contient l’ID de tâche. Conservez-le pour le dépannage.
EVENT_VAD_START	Déclenché après le démarrage de la tâche. Cet événement n’indique pas la détection du début de la parole.
EVENT_VAD_END	La fin de la parole a été détectée.
EVENT_SENTENCE_START	Le début d’un énoncé a été détecté.
EVENT_ASR_PARTIAL_RESULT	Un résultat de reconnaissance intermédiaire est disponible.
EVENT_SENTENCE_END	La fin d’un énoncé a été détectée et son résultat complet est disponible.
EVENT_ASR_WARN	Un avertissement non fatal s’est produit pendant la reconnaissance, par exemple une interruption réseau lorsque la reconnexion est activée.
EVENT_ASR_ERROR	Une erreur s’est produite pendant la reconnaissance. resultCode contient le code d’erreur.
EVENT_MIC_ERROR	Aucune donnée audio reçue pendant deux secondes consécutives. Vérifiez le code d’enregistrement, les autorisations ou l’utilisation du microphone par une autre application.
EVENT_TRANSCRIBER_COMPLETE	La reconnaissance est terminée.
EVENT_AEC_DATA	Données audio traitées par l’AEC, renvoyées via onNuiAssistEventCallback.

onNuiAudioStateChanged

onNuiAudioStateChanged: (state: Constants.AudioState) => void;

Le SDK utilise ce rappel pour indiquer à l'application quand démarrer ou arrêter l'enregistrement.

State	Description
STATE_OPEN	L’interaction a démarré. L’appareil d’enregistrement peut être ouvert.
STATE_PAUSE	L’interaction s’est arrêtée. L’enregistrement peut être arrêté.
STATE_CLOSE	L’instance SDK a été libérée. L’appareil d’enregistrement peut être fermé complètement.

Sur HarmonyOS, AudioCapturer est créé de façon asynchrone. Créez l'enregistreur pendant l'initialisation. À STATE_CLOSE, arrêtez l'enregistrement mais conservez l'instance pour la réutiliser, puis libérez-la dans le flux unifié release. Cela évite qu'un enregistreur en cours de recréation ignore un appel immédiat à start à l'arrivée du prochain STATE_OPEN.

onNuiNeedAudioData

onNuiNeedAudioData: (buffer: ArrayBuffer) => number;

Appelé en continu lorsque le SDK récupère l'audio. Remplissez buffer.byteLength octets, généralement 20 ms de PCM mono 16 bits, et renvoyez le nombre d'octets écrits. Une valeur ≤ 0 indique une erreur ou l'absence de données.

onNuiAudioRMSChanged

onNuiAudioRMSChanged: (val: number) => number;

Signale le volume actuel pour mettre à jour l'interface. Si audio_config.mic.volume_mode vaut "dbfs", val va de -160 à 0. L'implémentation du rappel peut renvoyer 0.

onNuiAssistEventCallback

onNuiAssistEventCallback?: (
  event: Constants.NuiEvent,
  info: string,
  infoLen: number,
  data: ArrayBuffer
) => void;

Rappel facultatif pour les événements et données auxiliaires internes du SDK. Omettez-le si ces informations ne sont pas nécessaires.

Paramètre	Type	Description
event	Constants.NuiEvent	Événement auxiliaire.
info	string	Informations supplémentaires, généralement une chaîne JSON.
infoLen	number	Longueur des informations supplémentaires.
data	ArrayBuffer	Données auxiliaires, telles que l’audio traité par l’AEC.

onNuiLogTrackCallback

onNuiLogTrackCallback: (level: Constants.LogLevel, log: string) => void;

Reçoit les journaux de suivi du SDK. Les niveaux renvoyés dépendent de log_track_level et de l'argument level de initialize.

Objets de résultat

AsrResult

Property	Type	Description
finish	boolean	Indique si le résultat actuel est final.
resultCode	number	Code d’état du résultat.
asrResult	string	Texte reconnu. Pour EVENT_ASR_ERROR, ce champ contient le message d’erreur.
allResponse	string	Réponse complète du serveur sous forme de chaîne JSON, avec l’ID de tâche et le texte de l’énoncé.

KwsResult

Property	Type	Description
type	Constants.WuwType	Type de mot d’activation. Ignorez ce champ pour la reconnaissance vocale en temps réel.
kws	string	Mot d’activation. Ignorez ce champ pour la reconnaissance vocale en temps réel.

Constantes et énumérations

Nom	Description
Constants.ModeType	Modes SDK : MODE_DIALOG, MODE_TTS et MODE_STREAM_INPUT_TTS.
Constants.VadMode	Mode VAD. La reconnaissance vocale en temps réel utilise TYPE_P2T ; l’utilisateur appelle stopDialog pour terminer la reconnaissance.
Constants.AudioState	États audio : STATE_OPEN, STATE_PAUSE et STATE_CLOSE.
Constants.LogLevel	Niveaux de journalisation de LOG_LEVEL_VERBOSE (0) à LOG_LEVEL_NONE (5).
Constants.NuiResultCode	Codes d’erreur SDK, par exemple SUCCESS (0), ILLEGAL_PARAM (240002), NECESSARY_PARAM_LACK (240004) et SDK_NOT_INIT (240011).
Constants.kServiceTypeSpeechTranscriber	Valeur de service_type pour la reconnaissance vocale en temps réel : 4.
Constants.ModeFullCloud	Mode entièrement cloud. La valeur de service_mode est "1".

Exemple de code

Le code suivant présente le flux principal du SDK. Pour la gestion complète des autorisations, la file d'enregistrement et l'analyse des réponses, consultez DashFunAsrSpeechTranscriberPage.ets dans le SDK.

import { AsrResult, Constants, INativeNuiCallback, KwsResult, NativeNui } from 'neonui';

const callback: INativeNuiCallback = {
  onNuiEventCallback: (event: Constants.NuiEvent, resultCode: number, arg2: number,
    kwsResult: KwsResult, asrResult: AsrResult): void => {
    if (event == Constants.NuiEvent.EVENT_ASR_PARTIAL_RESULT
      || event == Constants.NuiEvent.EVENT_SENTENCE_END) {
      // Parse payload.output.sentence.text from asrResult.allResponse.
    } else if (event == Constants.NuiEvent.EVENT_TRANSCRIBER_COMPLETE) {
      // Recognition is complete.
    } else if (event == Constants.NuiEvent.EVENT_ASR_ERROR) {
      // resultCode contains the error code.
    }
  },
  onNuiAudioStateChanged: (state: Constants.AudioState): void => {
    // Control AudioCapturer for STATE_OPEN, STATE_PAUSE, and STATE_CLOSE.
  },
  onNuiNeedAudioData: (buffer: ArrayBuffer): number => {
    // Copy recording data to buffer and return the number of bytes written.
    return 0;
  },
  onNuiAudioRMSChanged: (val: number): number => 0,
  onNuiLogTrackCallback: (level: Constants.LogLevel, log: string): void => {}
};

const nuiInstance = new NativeNui(Constants.ModeType.MODE_DIALOG);

const initParams: Record<string, Object> = {};
initParams['url'] = 'wss://dashscope.aliyuncs.com/api-ws/v1/inference';
initParams['device_id'] = 'my_device_id';
initParams['service_mode'] = Constants.ModeFullCloud;
initParams['audio_update_manually'] = 'false';

const initResult = nuiInstance.initialize(
  callback,
  JSON.stringify(initParams),
  Constants.LogLevel.LOG_LEVEL_DEBUG,
  false
);

if (initResult == Constants.NuiResultCode.SUCCESS) {
  const nlsConfig: Record<string, Object> = {
    'model': 'fun-asr-realtime',
    'sr_format': 'opus',
    'sample_rate': 16000
  };
  const params: Record<string, Object> = {
    'service_type': Constants.kServiceTypeSpeechTranscriber,
    'nls_config': nlsConfig
  };
  nuiInstance.setParams(JSON.stringify(params));

  const dialogParams: Record<string, Object> = { 'apikey': 'st-****' };
  nuiInstance.startDialog(Constants.VadMode.TYPE_P2T, JSON.stringify(dialogParams));
}

// Stop recognition when the user finishes recording, and wait for EVENT_TRANSCRIBER_COMPLETE.
function stopRecognition(): void {
  nuiInstance.stopDialog();
}
// Call nuiInstance.release() from the EVENT_TRANSCRIBER_COMPLETE handler.

Utilisez AudioCapturer de @kit.AudioKit pour enregistrer. L'audio doit être en PCM mono 16 bits, à un taux d'échantillonnage pris en charge par le modèle sélectionné.

import { audio } from '@kit.AudioKit';

const options: audio.AudioCapturerOptions = {
  streamInfo: {
    samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_16000,
    channels: audio.AudioChannel.CHANNEL_1,
    sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
    encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
  },
  capturerInfo: {
    source: audio.SourceType.SOURCE_TYPE_MIC,
    capturerFlags: 0
  }
};

const capturer = await audio.createAudioCapturer(options);
capturer.on('readData', (buffer: ArrayBuffer): void => {
  // Pull mode: enqueue data for onNuiNeedAudioData.
  // Push mode: call nuiInstance.updateAudio(buffer, firstPack).
});
await capturer.start();