/// <summary>Snippet for StreamingDetectIntent</summary>
public async Task StreamingDetectIntent()
{
// Snippet: StreamingDetectIntent(CallSettings, BidirectionalStreamingSettings)
// Create client
SessionsClient sessionsClient = SessionsClient.Create();
// Initialize streaming call, retrieving the stream object
SessionsClient.StreamingDetectIntentStream response = sessionsClient.StreamingDetectIntent();
// Sending requests and retrieving responses can be arbitrarily interleaved
// Exact sequence will depend on client/server behavior
// Create task to do something with responses from server
Task responseHandlerTask = Task.Run(async() =>
{
// Note that C# 8 code can use await foreach
AsyncResponseStream <StreamingDetectIntentResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingDetectIntentResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
});
// Send requests to the server
bool done = false;
while (!done)
{
// Initialize a request
StreamingDetectIntentRequest request = new StreamingDetectIntentRequest
{
Session = "",
QueryParams = new QueryParameters(),
QueryInput = new QueryInput(),
OutputAudioConfig = new OutputAudioConfig(),
InputAudio = ByteString.Empty,
OutputAudioConfigMask = new FieldMask(),
};
// Stream a request to the server
await response.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await response.WriteCompleteAsync();
// Await the response handler
// This will complete once all server responses have been processed
await responseHandlerTask;
// End snippet
}
/// <summary>Snippet for StreamingDetectIntent</summary>
public async Task StreamingDetectIntent()
{
// Snippet: StreamingDetectIntent(CallSettings,BidirectionalStreamingSettings)
// Create client
SessionsClient sessionsClient = SessionsClient.Create();
// Initialize streaming call, retrieving the stream object
SessionsClient.StreamingDetectIntentStream duplexStream = sessionsClient.StreamingDetectIntent();
// Sending requests and retrieving responses can be arbitrarily interleaved.
// Exact sequence will depend on client/server behavior.
// Create task to do something with responses from server
Task responseHandlerTask = Task.Run(async() =>
{
IAsyncEnumerator <StreamingDetectIntentResponse> responseStream = duplexStream.ResponseStream;
while (await responseStream.MoveNext())
{
StreamingDetectIntentResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
});
// Send requests to the server
bool done = false;
while (!done)
{
// Initialize a request
StreamingDetectIntentRequest request = new StreamingDetectIntentRequest
{
Session = "",
QueryInput = new QueryInput(),
};
// Stream a request to the server
await duplexStream.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await duplexStream.WriteCompleteAsync();
// Await the response handler.
// This will complete once all server responses have been processed.
await responseHandlerTask;
// End snippet
}
/// <summary>
/// Detects the intent from a stream asynchronously.
/// </summary>
/// <param name="projectId">The project identifier.</param>
/// <param name="sessionId">The session identifier.</param>
/// <param name="filePath">The file path.</param>
/// <returns>The detected results from dialogflow.</returns>
public async Task <List <QueryResult> > DetectIntentFromStreamAsync(string projectId, string sessionId, string filePath)
{
List <QueryResult> results = new List <QueryResult>();
SessionsClient client = SessionsClient.Create();
var sessionName = SessionName.FromProjectSession(projectId, sessionId).ToString();
// Initialize streaming call, retrieving the stream object
var streamingDetectIntent = client.StreamingDetectIntent();
// Define a task to process results from the API
var responseHandlerTask = Task.Run(async() =>
{
var responseStream = streamingDetectIntent.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
var response = responseStream.Current;
var queryResult = response.QueryResult;
if (queryResult != null)
{
Console.WriteLine($"Query text: {queryResult.QueryText}");
if (queryResult.Intent != null)
{
Console.Write("Intent detected:");
Console.WriteLine(queryResult.Intent.DisplayName);
}
results.Add(queryResult);
}
}
});
// Instructs the speech recognizer how to process the audio content.
// Note: hard coding audioEncoding, sampleRateHertz for simplicity.
var queryInput = new QueryInput
{
AudioConfig = new InputAudioConfig
{
AudioEncoding = AudioEncoding.Linear16,
LanguageCode = "de-DE",
SampleRateHertz = 11025
}
};
// The first request must **only** contain the audio configuration:
await streamingDetectIntent.WriteAsync(new StreamingDetectIntentRequest
{
QueryInput = queryInput,
Session = sessionName
});
try
{
using (var fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None))
{
// Subsequent requests must **only** contain the audio data.
// Following messages: audio chunks. We just read the file in
// fixed-size chunks. In reality you would split the user input
// by time.
var buffer = new byte[32 * 1024];
int bytesRead;
while ((bytesRead = await fs.ReadAsync(
buffer, 0, buffer.Length)) > 0)
{
await streamingDetectIntent.WriteAsync(new StreamingDetectIntentRequest
{
Session = sessionName,
InputAudio = Google.Protobuf.ByteString.CopyFrom(buffer, 0, bytesRead)
});
}
;
}
}
catch { }
// Tell the service you are done sending data
await streamingDetectIntent.WriteCompleteAsync();
// This will complete once all server responses have been processed.
await responseHandlerTask;
return(results);
}
