Avvio rapido: Conversazione per più dispositivi

Questo argomento di avvio rapido illustra come usare Speech SDK per creare una nuova conversazione per più dispositivi con il supporto della traduzione, nonché per partecipare a una conversazione esistente.

Nota

Speech SDK per Java, JavaScript, Objective-C e Swift supportano la conversazione per più dispositivi, ma non è ancora stata inclusa una guida.

È possibile visualizzare o scaricare tutti gli esempi C# di Speech SDK in GitHub.

Prerequisiti

Prima di iniziare, assicurarsi di:

• Creare una risorsa Voce
• Configurare l'ambiente di sviluppo e creare un progetto vuoto

Aggiungere il codice di esempio

1. Aprire Program.cs e sostituire tutto il codice con il codice seguente:

   using Microsoft.CognitiveServices.Speech;
   using Microsoft.CognitiveServices.Speech.Audio;
   using Microsoft.CognitiveServices.Speech.Transcription;
   using System;
   using System.Threading.Tasks;
   
   namespace HelloWorld
   {
       class Program
       {
           static async Task Main(string[] args)
           {
               await CreateConversationAsync();
           }
   
           static async Task CreateConversationAsync()
           {
               // Replace these values with the details of your Cognitive Speech subscription
               string subscriptionKey = "YourSubscriptionKey";
   
               // Replace below with your region identifier from here: https://aka.ms/speech/sdkregion
               string region = "YourServiceRegion";
   
               // Sets source and target languages.
               // Replace with the languages of your choice, from list found here: https://aka.ms/speech/sttt-languages
               string fromLanguage = "en-US";
               string toLanguage = "de";
   
               // Set this to the display name you want for the conversation host
               string displayName = "The host";
   
               // Create the task completion source that will be used to wait until the user presses Ctrl + C
               var completionSource = new TaskCompletionSource<bool>();
   
               // Register to listen for Ctrl + C
               Console.CancelKeyPress += (s, e) =>
               {
                   completionSource.TrySetResult(true);
                   e.Cancel = true; // don't terminate the current process
               };
   
               // Create an instance of the speech translation config
               var config = SpeechTranslationConfig.FromSubscription(subscriptionKey, region);
               config.SpeechRecognitionLanguage = fromLanguage;
               config.AddTargetLanguage(toLanguage);
   
               // Create the conversation
               using (var conversation = await Conversation.CreateConversationAsync(config).ConfigureAwait(false))
               {
                   // Start the conversation so the host user and others can join
                   await conversation.StartConversationAsync().ConfigureAwait(false);
   
                   // Get the conversation ID. It will be up to your scenario to determine how this is shared with other participants.
                   string conversationId = conversation.ConversationId;
                   Console.WriteLine($"Created '{conversationId}' conversation");
   
                   // At this point, you can use the conversation object to manage the conversation. 
                   // For example, to mute everyone else in the room you can call this method:
                   await conversation.MuteAllParticipantsAsync().ConfigureAwait(false);
   
                   // Configure which audio source you want to use. If you are using a text only language, you 
                   // can use the other overload of the constructor that takes no arguments
                   var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
                   using (var conversationTranslator = new ConversationTranslator(audioConfig))
                   {
                       // You should connect all the event handlers you need at this point
                       conversationTranslator.SessionStarted += (s, e) =>
                       {
                           Console.WriteLine($"Session started: {e.SessionId}");
                       };
                       conversationTranslator.SessionStopped += (s, e) =>
                       {
                           Console.WriteLine($"Session stopped: {e.SessionId}");
                       };
                       conversationTranslator.Canceled += (s, e) =>
                       {
                           switch (e.Reason)
                           {
                               case CancellationReason.EndOfStream:
                                   Console.WriteLine($"End of audio reached");
                                   break;
   
                               case CancellationReason.Error:
                                   Console.WriteLine($"Canceled due to error. {e.ErrorCode}: {e.ErrorDetails}");
                                   break;
                           }
                       };
                       conversationTranslator.ConversationExpiration += (s, e) =>
                       {
                           Console.WriteLine($"Conversation will expire in {e.ExpirationTime.TotalMinutes} minutes");
                       };
                       conversationTranslator.ParticipantsChanged += (s, e) =>
                       {
                           Console.Write("The following participant(s) have ");
                           switch (e.Reason)
                           {
                               case ParticipantChangedReason.JoinedConversation:
                                   Console.Write("joined");
                                   break;
   
                               case ParticipantChangedReason.LeftConversation:
                                   Console.Write("left");
                                   break;
   
                               case ParticipantChangedReason.Updated:
                                   Console.Write("been updated");
                                   break;
                           }
   
                           Console.WriteLine(":");
   
                           foreach (var participant in e.Participants)
                           {
                               Console.WriteLine($"\t{participant.DisplayName}");
                           }
                       };
                       conversationTranslator.TextMessageReceived += (s, e) =>
                       {
                           Console.WriteLine($"Received an instant message from '{e.Result.ParticipantId}': '{e.Result.Text}'");
                           foreach (var entry in e.Result.Translations)
                           {
                               Console.WriteLine($"\tTranslated into '{entry.Key}': '{entry.Value}'");
                           }
                       };
                       conversationTranslator.Transcribed += (s, e) =>
                       {
                           Console.WriteLine($"Received a transcription from '{e.Result.ParticipantId}': '{e.Result.Text}'");
                           foreach (var entry in e.Result.Translations)
                           {
                               Console.WriteLine($"\tTranslated into '{entry.Key}': '{entry.Value}'");
                           }
                       };
                       conversationTranslator.Transcribing += (s, e) =>
                       {
                           Console.WriteLine($"Received a partial transcription from '{e.Result.ParticipantId}': '{e.Result.Text}'");
                           foreach (var entry in e.Result.Translations)
                           {
                               Console.WriteLine($"\tTranslated into '{entry.Key}': '{entry.Value}'");
                           }
                       };
   
                       // Enter the conversation to start receiving events
                       await conversationTranslator.JoinConversationAsync(conversation, displayName).ConfigureAwait(false);
   
                       // You can now send an instant message to all other participants in the room
                       await conversationTranslator.SendTextMessageAsync("The instant message to send").ConfigureAwait(false);
   
                       // If specified a speech to text language, you can start capturing audio
                       await conversationTranslator.StartTranscribingAsync().ConfigureAwait(false);
                       Console.WriteLine("Started transcribing. Press Ctrl + c to stop");
   
                       // At this point, you should start receiving transcriptions for what you are saying using the default microphone. Press Ctrl+c to stop audio capture
                       await completionSource.Task.ConfigureAwait(false);
   
                       // Stop audio capture
                       await conversationTranslator.StopTranscribingAsync().ConfigureAwait(false);
   
                       // Leave the conversation. After this you will no longer receive events
                       await conversationTranslator.LeaveConversationAsync().ConfigureAwait(false);
                   }
   
                   // End the conversation
                   await conversation.EndConversationAsync().ConfigureAwait(false);
   
                   // Delete the conversation. Any other participants that are still in the conversation will be removed
                   await conversation.DeleteConversationAsync().ConfigureAwait(false);
               }
           }
       }
   }
   

2. Nello stesso file sostituire la stringa YourSubscriptionKey con la chiave di sottoscrizione di Servizi cognitivi.

3. Sostituire la stringa YourServiceRegion con l'area associata alla sottoscrizione.

4. Dalla barra dei menu scegliere File>Salva tutto.

Compilare ed eseguire l'applicazione per creare una nuova conversazione

1. Dalla barra dei menu scegliere Compila>Compila soluzione per compilare l'applicazione. Il codice dovrebbe ora risultare compilato senza errori.

2. Scegliere Debug>Avvia debug o premere F5 per avviare l'applicazione helloworld.

3. Quando viene visualizzato il messaggio Started transcribing, è possibile iniziare a parlare. Mentre si parla, verrà visualizzata la trascrizione.

   • Se si condivide il codice di conversazione con altre persone che partecipano alla conversazione, verranno visualizzate anche le loro trascrizioni.

4. Al termine, premere CTRL + C per arrestare l'acquisizione di audio e terminare la conversazione.

Compilare ed eseguire l'applicazione per partecipare a una conversazione esistente

1. Copiare e incollare la funzione seguente nel file Program.cs:

   static async Task JoinConversationAsync(string conversationId)
   {
       // Set this to the display name you want for the participant
       string displayName = "participant";
   
       // Set the speech to text, or text language you want to use
       string language = "en-US";
   
       // Create the task completion source that will be used to wait until the user presses Ctrl + c
       var completionSource = new TaskCompletionSource<bool>();
   
       // Register to listen for Ctrl+C
       Console.CancelKeyPress += (s, e) =>
       {
           completionSource.TrySetResult(true);
           e.Cancel = true; // don't terminate the current process
       };
   
       // As a participant, you don't need to specify any subscription key, or region. You can directly create
       // the conversation translator object
       var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
       using (var conversationTranslator = new ConversationTranslator(audioConfig))
       {
           // Register for any events you are interested here. For now let's just register for
           // transcription, and instant message events
           conversationTranslator.TextMessageReceived += (s, e) =>
           {
               Console.WriteLine($"Received an instant message from '{e.Result.ParticipantId}': '{e.Result.Text}'");
               foreach (var entry in e.Result.Translations)
               {
                   Console.WriteLine($"\tTranslated into '{entry.Key}': '{entry.Value}'");
               }
           };
           conversationTranslator.Transcribed += (s, e) =>
           {
               Console.WriteLine($"Received a transcription from '{e.Result.ParticipantId}': '{e.Result.Text}'");
               foreach (var entry in e.Result.Translations)
               {
                   Console.WriteLine($"\tTranslated into '{entry.Key}': '{entry.Value}'");
               }
           };
           conversationTranslator.Transcribing += (s, e) =>
           {
               Console.WriteLine($"Received a partial transcription from '{e.Result.ParticipantId}': '{e.Result.Text}'");
               foreach (var entry in e.Result.Translations)
               {
                   Console.WriteLine($"\tTranslated into '{entry.Key}': '{entry.Value}'");
               }
           };
   
           // To start receiving events, you will need to join the conversation
           await conversationTranslator.JoinConversationAsync(conversationId, displayName, language).ConfigureAwait(false);
   
           // You can now send an instant message
           await conversationTranslator.SendTextMessageAsync("Message from participant").ConfigureAwait(false);
   
           // Start capturing audio if you specified a speech to text language
           await conversationTranslator.StartTranscribingAsync().ConfigureAwait(false);
           Console.WriteLine("Started transcribing. Press Ctrl-C to stop");
   
           // At this point, you should start receiving transcriptions for what you are saying using
           // the default microphone. Press Ctrl+C to stop audio capture
           await completionSource.Task.ConfigureAwait(false);
   
           // Stop audio capture
           await conversationTranslator.StopTranscribingAsync().ConfigureAwait(false);
   
           // Leave the conversation. You will stop receiving events after this
           await conversationTranslator.LeaveConversationAsync().ConfigureAwait(false);
       }
   }
   

2. Sostituire CreateConversationAsync(); nella funzione public static async Task Main(string[] args) con:

   // Set this to the conversation you want to join
   JoinConversationAsync("YourConversationId");
   

3. È necessario creare una conversazione a cui è possibile partecipare:

   1. Avviare il browser e passare a https://translator.microsoft.com.
   2. Selezionare "Avvia conversazione".
   3. Accedere con una delle opzioni disponibili.
   4. Digitare un nome, ad esempio Organizzatore.
   5. Selezionare una lingua, ad esempio l'italiano.
   6. Selezionare il pulsante INVIO.
   7. Prendere nota del codice di conversazione nella parte superiore della pagina.

   Suggerimento

   Se si usa il pulsante Copia nella pagina Web, assicurarsi di rimuovere translate.it/ all'avvio. È necessario solo l'ID di conversazione di 5 caratteri, ad esempio ABCDE.

4. Tornare in Visual Studio e sostituire la stringa YourConversationId con l'ID conversazione creato nel passaggio precedente.

5. Dalla barra dei menu scegliere Compila>Compila soluzione per compilare l'applicazione. Il codice dovrebbe ora risultare compilato senza errori.

6. Scegliere Debug>Avvia debug o premere F5 per avviare l'applicazione helloworld.

7. Quando viene visualizzato il messaggio Started transcribing, è possibile iniziare a parlare. Mentre si parla, verrà visualizzata la trascrizione.

   • Se si torna al browser, verranno visualizzate anche qui le trascrizioni mentre si parla.

8. Al termine, premere CTRL + C per arrestare l'acquisizione di audio e terminare la conversazione.

9. Tornare nel browser e uscire dalla conversazione usando il pulsante Esci nell'angolo in alto a destra.

Passaggi successivi

Esaminare gli esempi di codice C# su GitHub

È possibile visualizzare o scaricare tutti gli esempi C++ di Speech SDK in GitHub.

Prerequisiti

Prima di iniziare, assicurarsi di:

• Creare una risorsa Voce
• Configurare l'ambiente di sviluppo e creare un progetto vuoto

Aggiungere il codice di esempio

1. In Visual Studio aprire il file di origine helloworld.cpp.

2. Sostituire tutto il codice con il frammento di codice seguente:

   #include "pch.h"
   
   #define WIN32_LEAN_AND_MEAN
   #include <Windows.h>
   
   #include <iostream>
   #include <thread>
   #include <future>
   #include <string>
   #include <speechapi_cxx.h>
   
   using namespace std::chrono_literals;
   using namespace Microsoft::CognitiveServices::Speech;
   using namespace Microsoft::CognitiveServices::Speech::Audio;
   using namespace Microsoft::CognitiveServices::Speech::Transcription;
   
   // Create a promise we will set when the user presses Ctrl-C
   std::promise<bool> promise;
   // Create the future we will use to wait for the promise to be fulfilled
   std::future<bool> future = promise.get_future();
   
   void StartNewConversation()
   {
       // Set these
       std::string subscriptionKey("YourSubscriptionKey");
   
       // Replace below with your own region identifier from here: https://aka.ms/speech/sdkregion
       std::string region("YourServiceRegion");
   
       std::string speechLanguage("en-US");
   
       // Create the conversation object you'll need to manage the conversation
       auto speechConfig = SpeechConfig::FromSubscription(subscriptionKey, region);
       speechConfig->SetSpeechRecognitionLanguage(speechLanguage);
       auto conversation = Conversation::CreateConversationAsync(speechConfig).get();
   
       // Start the conversation so you and others can join
       conversation->StartConversationAsync().get();
   
       // Get the conversation ID. It will be up to your scenario to determine how this is shared with other participants.
       std::cout << "Created conversation: " << conversation->GetConversationId() << std::endl;
   
       // You can now call various commands to manage the room. For example:
       conversation->MuteAllParticipantsAsync().get();
   
       // Create the conversation translator you'll need to send audio, send IMs, and receive conversation events
       auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
       auto conversationTranslator = ConversationTranslator::FromConfig(audioConfig);
   
       // Add any event handlers
       conversationTranslator->SessionStarted += [](const SessionEventArgs& args)
       {
           std::cout << "Session started " << args.SessionId << std::endl;
       };
       conversationTranslator->SessionStopped += [](const SessionEventArgs& args)
       {
           std::cout << "Session stopped " << args.SessionId << std::endl;
       };
       conversationTranslator->Canceled += [](const ConversationTranslationCanceledEventArgs& args)
       {
           switch (args.Reason)
           {
               case CancellationReason::EndOfStream:
                   std::cout << "End of audio reached" << std::endl;
                   break;
   
               case CancellationReason::Error:
                   std::cout << "Canceled due to error. " << (long)args.ErrorCode << ": " << args.ErrorDetails << std::endl;
                   break;
           }
       };
       conversationTranslator->ConversationExpiration += [](const ConversationExpirationEventArgs& args)
       {
           std::cout << "Conversation will expire in " << args.ExpirationTime.count() << " minutes" << std::endl;
       };
       conversationTranslator->ParticipantsChanged += [](const ConversationParticipantsChangedEventArgs& args)
       {
           std::cout << "The following participant(s) have ";
           switch (args.Reason)
           {
               case ParticipantChangedReason::JoinedConversation:
                   std::cout << "joined";
                   break;
   
               case ParticipantChangedReason::LeftConversation:
                   std::cout << "left";
                   break;
   
               case ParticipantChangedReason::Updated:
                   std::cout << "been updated";
                   break;
           }
   
           std::cout << ":" << std::endl;
   
           for(std::shared_ptr<Participant> participant : args.Participants)
           {
               std::cout << "\t" << participant->DisplayName << std::endl;
           }
       };
       conversationTranslator->Transcribing += [](const ConversationTranslationEventArgs& args)
       {
           std::cout << "Received a partial transcription from " << args.Result->ParticipantId << ": " << args.Result->Text << std::endl;
           for (const auto& entry : args.Result->Translations)
           {
               std::cout << "\t" << entry.first << ": " << entry.second << std::endl;
           }
       };
       conversationTranslator->Transcribed += [](const ConversationTranslationEventArgs& args)
       {
           std::cout << "Received a transcription from " << args.Result->ParticipantId << ": " << args.Result->Text << std::endl;
           for (const auto& entry : args.Result->Translations)
           {
               std::cout << "\t" << entry.first << ": " << entry.second << std::endl;
           }
       };
       conversationTranslator->TextMessageReceived += [](const ConversationTranslationEventArgs& args)
       {
           std::cout << "Received an instant message from " << args.Result->ParticipantId << ": " << args.Result->Text << std::endl;
           for (const auto& entry : args.Result->Translations)
           {
               std::cout << "\t" << entry.first << ": " << entry.second << std::endl;
           }
       };
   
       // Join the conversation so you can start receiving events
       conversationTranslator->JoinConversationAsync(conversation, "Test Host").get();
   
       // Send an instant message
       conversationTranslator->SendTextMessageAsync("This is a short test message").get();
   
       // Start sending audio
       conversationTranslator->StartTranscribingAsync().get();
       std::cout << "Started transcribing. Press Ctrl + C to stop" << std::endl;
       future.get(); // wait for Ctrl - C to be pressed
   
       // Stop audio capture
       conversationTranslator->StopTranscribingAsync().get();
   
       // Leave the conversation. You will stop receiving events
       conversationTranslator->LeaveConversationAsync().get();
   
       // Once you are done, remember to delete the conversation.
       conversation->EndConversationAsync().get(); // You will not be able to rejoin after this
       conversation->DeleteConversationAsync().get(); // All participants still in the room will be ejected
   }
   
   int main()
   {
       // Register a handler for the Ctrl - C callback
       SetConsoleCtrlHandler(
           [](DWORD dwCtrlType) -> BOOL
           {
               if (dwCtrlType == CTRL_C_EVENT)
               {
                   // Signal that the user has pressed ctrl + C
                   promise.set_value(true);
                   return TRUE;
               }
   
               return FALSE;
           },
           TRUE);
   
       StartNewConversation();
   }
   

3. Nello stesso file, sostituire la stringa YourSubscriptionKey con la chiave di sottoscrizione.

4. Sostituire la stringa YourServiceRegion con l'area associata alla sottoscrizione.

5. Dalla barra dei menu scegliere File>Salva tutto.

Compilare ed eseguire l'applicazione per creare una nuova conversazione

1. Dalla barra dei menu scegliere Compila>Compila soluzione per compilare l'applicazione. Il codice dovrebbe ora risultare compilato senza errori.

2. Scegliere Debug>Avvia debug o premere F5 per avviare l'applicazione helloworld.

3. Quando viene visualizzato il messaggio Started transcribing, è possibile iniziare a parlare. Mentre si parla, verrà visualizzata la trascrizione

   • Se si condivide il codice di conversazione con altre persone che partecipano alla conversazione, verranno visualizzate anche le loro trascrizioni.

4. Al termine, premere CTRL + C per arrestare l'acquisizione di audio.

   Nota

   È possibile che venga visualizzato un messaggio da Visual Studio su un'eccezione simile al seguente: Exception thrown at 0x76EB90BF (KernelBase.dll) in helloworld.exe: 0x40010005: Control-C. È possibile ignorare questo problema in modo sicuro.
   
   Premere F5 per continuare.

Compilare ed eseguire l'applicazione per partecipare a una conversazione esistente

1. Copiare e incollare la funzione seguente in helloworld.cpp immediatamente prima della funzione int main():

   void JoinExistingConversation(const std::string& conversationId)
   {
       std::string speechLanguage("en-US");
   
       // You'll now need to create a ConversationTranslator to send audio, send IMs, and receive conversation events
       auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
       auto conversationTranslator = ConversationTranslator::FromConfig(audioConfig);
   
       // Attach event handlers here. For example:
       conversationTranslator->Transcribing += [](const ConversationTranslationEventArgs& args)
       {
           std::cout << "Received a partial transcription from " << args.Result->ParticipantId << ": " << args.Result->Text << std::endl;
           for (const auto& entry : args.Result->Translations)
           {
               std::cout << "\t" << entry.first << ": " << entry.second << std::endl;
           }
       };
       conversationTranslator->Transcribed += [](const ConversationTranslationEventArgs& args)
       {
           std::cout << "Received a transcription from " << args.Result->ParticipantId << ": " << args.Result->Text << std::endl;
           for (const auto& entry : args.Result->Translations)
           {
               std::cout << "\t" << entry.first << ": " << entry.second << std::endl;
           }
       };
       conversationTranslator->TextMessageReceived += [](const ConversationTranslationEventArgs& args)
       {
           std::cout << "Received an instant message from " << args.Result->ParticipantId << ": " << args.Result->Text << std::endl;
           for (const auto& entry : args.Result->Translations)
           {
               std::cout << "\t" << entry.first << ": " << entry.second << std::endl;
           }
       };
   
       // Join the conversation
       conversationTranslator->JoinConversationAsync(conversationId, "participant", speechLanguage).get();
   
       // Start sending audio
       conversationTranslator->StartTranscribingAsync().get();
       std::cout << "Started transcribing. Press Ctrl + C to stop" << std::endl;
       future.get(); // wait for Ctrl - C to be pressed
   
       // Stop audio capture
       conversationTranslator->StopTranscribingAsync().get();
   
       // Once you are done, leave the conversation
       conversationTranslator->LeaveConversationAsync().get();
   }
   

2. Sostituire StartNewConversation(); nella funzione int main() con:

   // Set this to the conversation you want to join
   JoinExistingConversation("YourConversationId");
   

3. È necessario creare una conversazione a cui è possibile partecipare:

   1. Avviare il browser e passare a https://translator.microsoft.com.
   2. Selezionare "Avvia conversazione".
   3. Accedere con una delle opzioni disponibili.
   4. Digitare un nome, ad esempio Organizzatore.
   5. Selezionare una lingua, ad esempio l'italiano.
   6. Selezionare il pulsante INVIO.
   7. Prendere nota del codice di conversazione nella parte superiore della pagina.

   Suggerimento

   Se si usa il pulsante Copia nella pagina Web, assicurarsi di rimuovere translate.it/ all'avvio. È necessario solo l'ID di conversazione di 5 caratteri, ad esempio ABCDE.

4. Tornare in Visual Studio e sostituire YourConversationId nella funzione int main() con l'ID conversazione creato nel passaggio precedente.

5. Dalla barra dei menu scegliere Compila>Compila soluzione per compilare l'applicazione. Il codice dovrebbe risultare compilato senza errori.

6. Scegliere Debug>Avvia debug o premere F5 per avviare l'applicazione helloworld.

7. Quando viene visualizzato il messaggio Started transcribing, è possibile iniziare a parlare. Mentre si parla, verrà visualizzata la trascrizione.

   • Se si torna al browser, verranno visualizzate anche qui le trascrizioni mentre si parla.

8. Al termine, premere CTRL + C per arrestare l'acquisizione di audio e terminare la conversazione.

   Nota

   È possibile che venga visualizzato un messaggio da Visual Studio su un'eccezione simile al seguente: Exception thrown at 0x76EB90BF (KernelBase.dll) in helloworld.exe: 0x40010005: Control-C. È possibile ignorare questo problema in modo sicuro.
   
   Premere F5 per continuare.

9. Tornare nel browser e uscire dalla conversazione usando il pulsante Esci nell'angolo in alto a destra.

Passaggi successivi

Esaminare gli esempi di codice C++ su GitHub