/// <summary>
/// Generate a presigned URL based on a <see cref="SynthesizeSpeechRequest"/>.
/// </summary>
/// <param name="credentials">The credentials to use in the presigned URL.</param>
/// <param name="region">The region for the URL.</param>
/// <param name="request">The request to base the presigned URL on.</param>
/// <returns></returns>
public static string GeneratePresignedUrl(AWSCredentials credentials, RegionEndpoint region, SynthesizeSpeechRequest request)
{
if (credentials == null)
throw new ArgumentNullException("credentials");
if (region == null)
throw new ArgumentNullException("region");
if (request == null)
throw new ArgumentNullException("request");
// Marshall this request and prepare it to be signed
var marshaller = new SynthesizeSpeechRequestMarshaller();
var iRequest = marshaller.Marshall(request);
iRequest.UseQueryString = true;
iRequest.HttpMethod = HTTPGet;
iRequest.Endpoint = new UriBuilder(HTTPS, region.GetEndpointForService(PollyServiceName).Hostname).Uri;
iRequest.Parameters[XAmzExpires] = ((int)FifteenMinutes.TotalSeconds).ToString(CultureInfo.InvariantCulture);
if (request.IsSetLexiconNames())
{
var sortedLexiconNames = new List<string>(request.LexiconNames);
sortedLexiconNames.Sort(StringComparer.Ordinal);
iRequest.Parameters[LexiconNamesParameter] = JsonMapper.ToJson(sortedLexiconNames);
}
if (request.IsSetOutputFormat())
iRequest.Parameters["OutputFormat"] = request.OutputFormat.ToString();
if (request.IsSetSampleRate())
iRequest.Parameters["SampleRate"] = request.SampleRate.ToString();
if (request.IsSetText())
iRequest.Parameters["Text"] = request.Text;
if (request.IsSetTextType())
iRequest.Parameters["TextType"] = request.TextType.ToString();
if (request.IsSetVoiceId())
iRequest.Parameters["VoiceId"] = request.VoiceId;
var immutableCredentials = credentials.GetCredentials();
if (immutableCredentials.UseToken)
{
// Don't use HeaderKeys.XAmzSecurityTokenHeader because Polly treats this as case-sensitive
iRequest.Parameters["X-Amz-Security-Token"] = immutableCredentials.Token;
}
// Only the host header should be signed, and the signer adds that.
// So clear out headers.
iRequest.Headers.Clear();
// Create presigned URL and assign it
var signingResult = SynthesizeSpeechPresignedUrlSigner.SignSynthesizeSpeechRequest(iRequest, new RequestMetrics(),
immutableCredentials.AccessKey, immutableCredentials.SecretKey, PollyServiceName, region.SystemName);
var authorization = "&" + signingResult.ForQueryParameters;
return ComposeUrl(iRequest).AbsoluteUri + authorization;
}
public void TestLexiconNames1()
{
var request = new SynthesizeSpeechRequest()
{
LexiconNames = new List<string>() { "lex1" }
};
var url = SynthesizeSpeechUtil.GeneratePresignedUrl(RegionEndpoint.USWest2, request);
Assert.IsTrue(url.Contains("LexiconNames=lex1"));
}
private Amazon.Polly.Model.SynthesizeSpeechResponse CallAWSServiceOperation(IAmazonPolly client, Amazon.Polly.Model.SynthesizeSpeechRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Polly", "SynthesizeSpeech");
try
{
#if DESKTOP
return(client.SynthesizeSpeech(request));
#elif CORECLR
return(client.SynthesizeSpeechAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.Polly.Model.SynthesizeSpeechRequest();
if (cmdletContext.Engine != null)
{
request.Engine = cmdletContext.Engine;
}
if (cmdletContext.LanguageCode != null)
{
request.LanguageCode = cmdletContext.LanguageCode;
}
if (cmdletContext.LexiconName != null)
{
request.LexiconNames = cmdletContext.LexiconName;
}
if (cmdletContext.OutputFormat != null)
{
request.OutputFormat = cmdletContext.OutputFormat;
}
if (cmdletContext.SampleRate != null)
{
request.SampleRate = cmdletContext.SampleRate;
}
if (cmdletContext.SpeechMarkType != null)
{
request.SpeechMarkTypes = cmdletContext.SpeechMarkType;
}
if (cmdletContext.Text != null)
{
request.Text = cmdletContext.Text;
}
if (cmdletContext.TextType != null)
{
request.TextType = cmdletContext.TextType;
}
if (cmdletContext.VoiceId != null)
{
request.VoiceId = cmdletContext.VoiceId;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
return(output);
}
/// <summary>
/// Generate a presigned URL based on a <see cref="SynthesizeSpeechRequest"/>
/// using the default configured credentials.
/// </summary>
/// <param name="region">The region for the URL.</param>
/// <param name="request">The request to base the presigned URL on.</param>
/// <returns></returns>
public static string GeneratePresignedUrl(RegionEndpoint region, SynthesizeSpeechRequest request)
{
AWSCredentials credentials = FallbackCredentialsFactory.GetCredentials();
return GeneratePresignedUrl(credentials, region, request);
}
/// <summary>
/// Initiates the asynchronous execution of the SynthesizeSpeech operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SynthesizeSpeech operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<SynthesizeSpeechResponse> SynthesizeSpeechAsync(SynthesizeSpeechRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SynthesizeSpeechRequestMarshaller();
var unmarshaller = SynthesizeSpeechResponseUnmarshaller.Instance;
return InvokeAsync<SynthesizeSpeechRequest,SynthesizeSpeechResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Synthesizes UTF-8 input, plain text or SSML, to a stream of bytes. SSML input must
/// be valid, well-formed SSML. Some alphabets might not be available with all the voices
/// (for example, Cyrillic might not be read at all by English voices) unless phoneme
/// mapping is used. For more information, see <a href="http://docs.aws.amazon.com/polly/latest/dg/how-text-to-speech-works.html">How
/// it Works</a>.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the SynthesizeSpeech service method.</param>
///
/// <returns>The response from the SynthesizeSpeech service method, as returned by Polly.</returns>
/// <exception cref="Amazon.Polly.Model.InvalidSampleRateException">
/// The specified sample rate is not valid.
/// </exception>
/// <exception cref="Amazon.Polly.Model.InvalidSsmlException">
/// The SSML you provided is invalid. Verify the SSML syntax, spelling of tags and values,
/// and then try again.
/// </exception>
/// <exception cref="Amazon.Polly.Model.LexiconNotFoundException">
/// Amazon Polly can't find the specified lexicon. This could be caused by a lexicon that
/// is missing, its name is misspelled or specifying a lexicon that is in a different
/// region.
///
///
/// <para>
/// Verify that the lexicon exists, is in the region (see <a>ListLexicons</a>) and that
/// you spelled its name is spelled correctly. Then try again.
/// </para>
/// </exception>
/// <exception cref="Amazon.Polly.Model.ServiceFailureException">
/// An unknown condition has caused a service failure.
/// </exception>
/// <exception cref="Amazon.Polly.Model.TextLengthExceededException">
/// The value of the "Text" parameter is longer than the accepted limits. The limit for
/// input text is a maximum of 3000 characters total, of which no more than 1500 can be
/// billed characters. SSML tags are not counted as billed characters.
/// </exception>
public SynthesizeSpeechResponse SynthesizeSpeech(SynthesizeSpeechRequest request)
{
var marshaller = new SynthesizeSpeechRequestMarshaller();
var unmarshaller = SynthesizeSpeechResponseUnmarshaller.Instance;
return Invoke<SynthesizeSpeechRequest,SynthesizeSpeechResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the SynthesizeSpeech operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SynthesizeSpeech operation on AmazonPollyClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSynthesizeSpeech
/// operation.</returns>
public IAsyncResult BeginSynthesizeSpeech(SynthesizeSpeechRequest request, AsyncCallback callback, object state)
{
var marshaller = new SynthesizeSpeechRequestMarshaller();
var unmarshaller = SynthesizeSpeechResponseUnmarshaller.Instance;
return BeginInvoke<SynthesizeSpeechRequest>(request, marshaller, unmarshaller,
callback, state);
}
public void TestLexiconNamesNull()
{
var request = new SynthesizeSpeechRequest();
var url = SynthesizeSpeechUtil.GeneratePresignedUrl(RegionEndpoint.USWest2, request);
Assert.IsFalse(url.Contains("LexiconNames"));
}