private async void Frame_Navigated(object sender, NavigationEventArgs e)
{
if (e != null)
{
var vm = NavigationService.GetNameOfRegisteredPage(e.SourcePageType);
var navigationItem = PrimaryItems?.FirstOrDefault(i => i.ViewModelName == vm);
if (navigationItem == null)
{
navigationItem = SecondaryItems?.FirstOrDefault(i => i.ViewModelName == vm);
}
if (navigationItem != null)
{
ChangeSelected(_lastSelectedItem, navigationItem);
_lastSelectedItem = navigationItem;
}
//Sentence 초기화
var init = Singleton <SentenceHelper> .Instance;
//마이크로 폰 권한 체크
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
var speechLanguage = SpeechRecognizer.SystemSpeechLanguage;
var langTag = speechLanguage.LanguageTag;
var speechContext = ResourceContext.GetForCurrentView();
speechContext.Languages = new[] { langTag };
}
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
//마이크로 폰 권한 체크
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
var speechLanguage = SpeechRecognizer.SystemSpeechLanguage;
var langTag = speechLanguage.LanguageTag;
var speechContext = ResourceContext.GetForCurrentView();
speechContext.Languages = new[] { langTag };
var supportedLanguages = SpeechRecognizer.SupportedGrammarLanguages;
var enUS = supportedLanguages.FirstOrDefault(p => p.LanguageTag == "en-US");
if (enUS == null)
{
enUS = SpeechRecognizer.SystemSpeechLanguage;
}
await InitializeRecognizerAsync(enUS);
}
_timer = new DispatcherTimer
{
Interval = TimeSpan.FromSeconds(10)
};
_timer.Tick += _timer_Tick;
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
// Keep track of the UI thread dispatcher, as speech events will come in on a separate thread.
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
// Prompt the user for permission to access the microphone. This request will only happen
// once, it will not re-prompt if the user rejects the permission.
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
// Initialize resource map to retrieve localized speech strings.
Language speechLanguage = SpeechRecognizer.SystemSpeechLanguage;
string langTag = speechLanguage.LanguageTag;
speechContext = ResourceContext.GetForCurrentView();
speechContext.Languages = new string[] { langTag };
speechResourceMap = ResourceManager.Current.MainResourceMap.GetSubtree("LocalizationSpeechResources");
PopulateLanguageDropdown();
await InitializeRecognizer(SpeechRecognizer.SystemSpeechLanguage);
TurnRecognizer1();
}
else
{
this.resultTextBlock.Visibility = Visibility.Visible;
this.resultTextBlock.Text = "Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.";
cbLanguageSelection.IsEnabled = false;
//luis
}
}
/// <summary>
/// When activating the scenario, ensure we have permission from the user to access their microphone, and
/// provide an appropriate path for the user to enable access to the microphone if they haven't
/// given explicit permission for it.
/// </summary>
/// <param name="e">The navigation event details</param>
private async Task InitSpeech()
{
// Save the UI thread dispatcher to allow speech status messages to be shown on the UI.
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
// Enable the recognition buttons.
button.IsEnabled = true;
if (speechRecognizer != null)
{
// cleanup prior to re-initializing this scenario.
//speechRecognizer.StateChanged -= SpeechRecognizer_StateChanged;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
// Create an instance of SpeechRecognizer.
speechRecognizer = new SpeechRecognizer();
// Provide feedback to the user about the state of the recognizer.
//speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
// Compile the dictation topic constraint, which optimizes for dictated speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
speechRecognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.HypothesisGenerated += SpeechRecognizer_HypothesisGenerated;
// Check to make sure that the constraints were in a proper format and the recognizer was able to compile it.
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
// Disable the recognition buttons.
button.IsEnabled = false;
// Let the user know that the grammar didn't compile properly.
//resultTextBlock.Visibility = Visibility.Visible;
//resultTextBlock.Text = "Unable to compile grammar.";
}
}
else
{
// "Permission to access capture resources was not given by the user; please set the application setting in Settings->Privacy->Microphone.";
button.IsEnabled = false;
}
await Task.Yield();
}
/// The methods provided in this section are simply used to allow
/// NavigationHelper to respond to the page's navigation methods.
///
/// Page specific logic should be placed in event handlers for the
/// <see cref="Common.NavigationHelper.LoadState"/>
/// and <see cref="Common.NavigationHelper.SaveState"/>.
/// The navigation parameter is available in the LoadState method
/// in addition to page state preserved during an earlier session.
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
navigationHelper.OnNavigatedTo(e);
// Prompt the user for permission to access the microphone. This request will only happen
// once, it will not re-prompt if the user rejects the permission.
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
speechLanguage = SpeechRecognizer.SystemSpeechLanguage;
string langTag = speechLanguage.LanguageTag;
// Initialize resource map to retrieve localized speech strings.
speechContext = ResourceContext.GetForCurrentView();
IReadOnlyList <Language> supportedLanguages = SpeechRecognizer.SupportedGrammarLanguages;
if (supportedLanguages.Count > 1)
{
if (Windows.Globalization.ApplicationLanguages.PrimaryLanguageOverride == "zh-Hans-CN")
{
speechContext.Languages = new string[] { "zh-Hans-CN" };
speechLanguage = new Windows.Globalization.Language("zh-Hans-CN");
}
else
{
speechContext.Languages = new string[] { "en-US" };
speechLanguage = new Windows.Globalization.Language("en-US");
}
}
else
{
speechContext.Languages = new string[] { langTag };
}
speechResourceMap = ResourceManager.Current.MainResourceMap.GetSubtree("LocalizationSpeechResources");
//Initia Command
await InitializeRecognizer(speechLanguage);
//Initia RecognizerNote
await InitializeRecognizerNote(speechLanguage);
if (speechRecognizer.State == SpeechRecognizerState.Idle && permissionGained)
{
try
{
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
catch (Exception ex)
{
var messageDialog = new Windows.UI.Popups.MessageDialog(ex.Message, "Exception");
await messageDialog.ShowAsync();
}
}
}
async Task RecordSpeechFromMicrophoneAsync(VoiceInformation voiceInformation)
{
if (!await AudioCapturePermissions.RequestMicrophonePermission())
{
return;
}
if (voiceInformation == null)
{
return;
}
if (!await DoRecognition())
{
await SpeakAndListen(listenOnly : true);
}
async Task <bool> DoRecognition()
{
using (SpeechRecognizer speechRecognizer = new SpeechRecognizer(new Windows.Globalization.Language(voiceInformation.Language)))
{
SpeechRecognitionConstraints.ToList().ForEach(c => speechRecognizer.Constraints.Add(c));
speechRecognizer.Timeouts.InitialSilenceTimeout = TimeSpan.FromSeconds(SpeechRecognitionConstants.InitialSilenceTimeout);
speechRecognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(SpeechRecognitionConstants.EndSilenceTimeout);
await speechRecognizer.CompileConstraintsAsync();
SpeechRecognitionResult result = await speechRecognizer.RecognizeAsync();
if (
result.Status == SpeechRecognitionResultStatus.Success &&
new HashSet <SpeechRecognitionConfidence>
{
SpeechRecognitionConfidence.High,
SpeechRecognitionConfidence.Medium,
SpeechRecognitionConfidence.Low
}.Contains(result.Confidence) &&
uiNotificationService.CanGoBack
)
{
await GoBack();
return(true);
}
else
{
return(false);
}
}
}
}
private async void RequestMicrophoneAcessIfUserWantsVoiceDetection()
{
if (Utils.IsListeningSettingEnabled())
{
if (await AudioCapturePermissions.RequestMicrophonePermission())
{
SpeechRecognitionManager.StartListeningForMainPage(performActionFromCommandBoxText, this.CommandBox);
}
else
{
TextToSpeechEngine.SpeakText(this.media, "Sorry, but something went wrong with setting up your microphone. You cannot use me through speech, but you can still use the command bar at the bottom of the screen.");
}
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
// Save the UI thread dispatcher to allow speech status messages to be shown on the UI.
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
}
else
{
}
await InitializeRecognizer(SpeechRecognizer.SystemSpeechLanguage);
}
private async Task Initialize()
{
// Prompt the user for permission to access the microphone.
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
this.mainPage.IsEnabled = true;
this.notificationControl.Visibility = Visibility.Visible;
this.targetLanguagesListView.IsEnabled = this.isAzureSpeechEndpoint;
timer = new DispatcherTimer();
timer.Tick += AutoStopRecognitionHandlerTimerTick;
timer.Interval = new TimeSpan(0, 0, RecognitionTimeLimitInSeconds);
recordingTimer = new DispatcherTimer();
recordingTimer.Tick += RecordingTimerTickHandler;
recordingTimer.Interval = new TimeSpan(0, 0, 1);
this.speechToTextView.ShowNotificationEventHandler += OnShowNotification;
this.speechToTextWithTranslation.ShowNotificationEventHandler += OnShowNotification;
this.speechToTextWithTranslation.Closed += (s, args) => {
SpeechExplorerState = oldSpeechExplorerState != SpeechExplorerState.SpeechToTextWithTranslation ? oldSpeechExplorerState : SpeechExplorerState.SpeechToText;
};
}
else
{
this.mainPage.IsEnabled = false;
this.notificationControl.Visibility = Visibility.Collapsed;
ContentDialog deleteFileDialog = new ContentDialog
{
Title = "Intelligent Kiosk can't access the microphone",
Content = "To let kiosk use this device's microphone, go to Windows Settings -> Apps and turn on microphone permissions for Intelligent Kiosk.",
PrimaryButtonText = "Open Settings",
CloseButtonText = "Close",
DefaultButton = ContentDialogButton.Primary
};
ContentDialogResult result = await deleteFileDialog.ShowAsync();
if (result == ContentDialogResult.Primary)
{
await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-microphone"));
}
}
}
private async Task InitializeAsync()
{
// if user haven't give permission to speec or app is running on a phone then the voice button has not to be shown
if (await AudioCapturePermissions.RequestMicrophonePermission())
{
//if (await Template10.Utils.AudioUtils.RequestMicrophonePermission() == false || DeviceUtils.Current().DeviceDisposition() == DeviceUtils.DeviceDispositions.Phone
// || DeviceUtils.Current().DeviceDisposition() == DeviceUtils.DeviceDispositions.Continuum)
VisualStateManager.GoToState(this, VISUAL_STATE_VOICE_DISABLED, true);
}
// if textbox is readonly there should not be possible to use voice recognition
if (this.IsReadOnly)
{
this.voiceButton.IsEnabled = false;
this.stopVoiceButton.IsEnabled = false;
}
}
/// <summary>
/// When activating the scenario, ensure we have permission from the user to access their microphone, and
/// provide an appropriate path for the user to enable access to the microphone if they haven't
/// given explicit permission for it.
/// </summary>
/// <param name="e">The navigation event details</param>
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
// Save the UI thread dispatcher to allow speech status messages to be shown on the UI.
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
// Enable the recognition buttons.
await InitializeRecognizer(SpeechRecognizer.SystemSpeechLanguage);
buttonOnListen.IsEnabled = true;
}
else
{
// Permission to access capture resources was not given by the user; please set the application setting in Settings->Privacy->Microphone.
buttonOnListen.IsEnabled = false;
}
}
public async void Page_Loaded(object sender, RoutedEventArgs e)
{
_dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
var permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (!permissionGained)
{
return;
}
await InitializeRecognizer(SpeechRecognizer.SystemSpeechLanguage);
// Za debugging: Prikaz poruke o detektovanom jeziku
// Poruka("Jezik: " + SpeechRecognizer.SystemSpeechLanguage.DisplayName, "Jezik");
await _speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
/// <summary>
/// Upon entering the scenario, ensure that we have permissions to use the Microphone. This may entail popping up
/// a dialog to the user on Desktop systems. Only enable functionality once we've gained that permission in order to
/// prevent errors from occurring when using the SpeechRecognizer. If speech is not a primary input mechanism, developers
/// should consider disabling appropriate parts of the UI if the user does not have a recording device, or does not allow
/// audio input.
/// </summary>
/// <param name="e">Unused navigation parameters</param>
protected async void VoiceStartup()
{
// Prompt the user for permission to access the microphone. This request will only happen
// once, it will not re-prompt if the user rejects the permission.
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
btnContinuousRecognize.IsEnabled = true;
await InitializeRecognizer(SpeechRecognizer.SystemSpeechLanguage);
}
else
{
this.commandBox.PlaceholderText = "Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.";
btnContinuousRecognize.IsEnabled = false;
// cbLanguageSelection.IsEnabled = false;
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
// Prompt the user for permission to access the microphone. This request will only happen
// once, it will not re-prompt if the user rejects the permission.
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
btnContinuousRecognize.IsEnabled = true;
PopulateLanguageDropdown();
await InitializeRecognizer(SpeechRecognizer.SystemSpeechLanguage);
}
else
{
this.dictationTextBox.Text = "Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.";
btnContinuousRecognize.IsEnabled = false;
cbLanguageSelection.IsEnabled = false;
}
}
public async void initializeSpeechRec()
{
TIASiml.initiateSIML();
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (!permissionGained)
{
MessageDialog("Permission to access capture resources was not given by the user, reset the application setting in Settings->Privacy->Microphone.");
}
this.dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
this.speechRecognizer = new SpeechRecognizer();
speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();
speechRecognizer.ContinuousRecognitionSession.Completed += ContinuousRecognitionSession_Completed;
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ContinuousRecognitionSession_ResultGenerated;
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}
private async void Main_LoadedAsync(object sender, RoutedEventArgs e)
{
cbVoice.Items.Clear();
foreach (var voice in SpeechSynthesizer.AllVoices)
{
cbVoice.Items.Add(voice.DisplayName);
if (voice.DisplayName == SpeechSynthesizer.DefaultVoice.DisplayName)
{
cbVoice.SelectedItem = cbVoice.Items.Last();
}
}
isListening = false;
// Prompt the user for permission to access the microphone. This request will only happen
// once, it will not re-prompt if the user rejects the permission.
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (permissionGained)
{
btnListen.IsEnabled = true;
btnListen.Visibility = Visibility.Visible;
cbLanguageSelection.Visibility = Visibility.Visible;
// Initialize resource map to retrieve localized speech strings.
Language speechLanguage = SpeechRecognizer.SystemSpeechLanguage;
string langTag = speechLanguage.LanguageTag;
speechContext = ResourceContext.GetForCurrentView();
speechContext.Languages = new string[] { langTag };
speechResourceMap = ResourceManager.Current.MainResourceMap.GetSubtree("LocalizationSpeechResources");
PopulateLanguageDropdown();
await InitializeRecognizer(SpeechRecognizer.SystemSpeechLanguage);
}
else
{
btnListen.IsEnabled = false;
btnListen.Visibility = Visibility.Collapsed;
cbLanguageSelection.Visibility = Visibility.Collapsed;
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e) //cuando llegas
{
// MQTT
MiMqtt = new mqtt();
MiMqtt.cliente.MqttMsgPublishReceived += cliente_MqttMsgPublishReceivedAsync; //registrarme al evento
// Presencia
miPresencia = new Presencia();
// VOZ
miEstado = Estado.Parado; //iniciamos parados
nextStep = Estado.Parado;
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
//comprobación de si tengo permiso sobre el micrófono; si tengo, inicio el proceso (InitializeRecognizer)
bool tengoPermiso = await AudioCapturePermissions.RequestMicrophonePermission();
if (tengoPermiso)
{
// inicializa el habla
inicializaHabla();
//escoge castellano (válido para todos los reconocedores)
Language speechLanguage = SpeechRecognizer.SystemSpeechLanguage;
// inicializo el reconocedor de gramática compilada
await InitializeRecognizer(speechLanguage);
//// y lanza el control de estados
await ControlEstado();
}
else
{
await dime("No tengo acceso al micrófono; cerrando");
MostrarTexto(txbEstado, "Sin acceso al micrófono");
}
}
public async Task <SpeechResult> RecognizeAsync(string listenText, string exampleText)
{
try
{
bool permissionGained = await AudioCapturePermissions.RequestMicrophonePermission();
if (!permissionGained)
{
await this.messageBoxService.ShowAsync(
StringResources.Message_Warning,
StringResources.Speech_ReviewPermission);
return(new SpeechResult(string.Empty, false));
}
SpeechRecognizer recognizer = new SpeechRecognizer(SpeechRecognizer.SystemSpeechLanguage);
recognizer.UIOptions.IsReadBackEnabled = false;
recognizer.UIOptions.ShowConfirmation = false;
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
recognizer.Constraints.Add(dictationConstraint);
SpeechRecognitionCompilationResult compilationResult = await recognizer.CompileConstraintsAsync();
if (compilationResult.Status == SpeechRecognitionResultStatus.Success)
{
SpeechRecognitionResult result = await recognizer.RecognizeWithUIAsync();
return(new SpeechResult(result.Text.Trim('.'), result.Status == SpeechRecognitionResultStatus.Success));
}
return(new SpeechResult(string.Empty, false));
}
catch (Exception e)
{
return(new SpeechResult(e.Message, false));
}
}
public async Task Initialize()
{
if (!this.permissionGained)
{
await WindowManagerService.Current.MainDispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => this.permissionGained = await AudioCapturePermissions.RequestMicrophonePermission());
}
try
{
if (this.speechRecognizer != null)
{
this.speechRecognizer.StateChanged -= this.SpeechRecognizer_StateChanged;
this.speechRecognizer.ContinuousRecognitionSession.Completed -= this.ContinuousRecognitionSession_Completed;
this.speechRecognizer.ContinuousRecognitionSession.ResultGenerated -= this.ContinuousRecognitionSession_ResultGenerated;
this.speechRecognizer.HypothesisGenerated -= this.SpeechRecognizer_HypothesisGenerated;
this.speechRecognizer.Dispose();
this.speechRecognizer = null;
}
var recognizerLanguage = new Language(App.Settings.SpeechLocale); // SpeechRecognizer.SystemSpeechLanguage
this.speechRecognizer = new SpeechRecognizer(recognizerLanguage);
// Provide feedback to the user about the state of the recognizer. This can be used to provide visual feedback in the form
// of an audio indicator to help the user understand whether they're being heard.
this.speechRecognizer.StateChanged += this.SpeechRecognizer_StateChanged;
// Apply the dictation topic constraint to optimize for dictated free-form speech.
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
this.speechRecognizer.Constraints.Add(dictationConstraint);
var result = await this.speechRecognizer.CompileConstraintsAsync();
if (result.Status != SpeechRecognitionResultStatus.Success)
{
await this.dialogService.ShowError(result.Status.ToString(), "Grammar Compilation Failed", "OK", null);
}
// Handle continuous recognition events. Completed fires when various error states occur. ResultGenerated fires when
// some recognized phrases occur, or the garbage rule is hit. HypothesisGenerated fires during recognition, and
// allows us to provide incremental feedback based on what the user's currently saying.
this.speechRecognizer.ContinuousRecognitionSession.Completed += this.ContinuousRecognitionSession_Completed;
this.speechRecognizer.ContinuousRecognitionSession.ResultGenerated += this.ContinuousRecognitionSession_ResultGenerated;
this.speechRecognizer.HypothesisGenerated += this.SpeechRecognizer_HypothesisGenerated;
await this.StartRecognizing(true);
}
catch (Exception ex)
{
if ((uint)ex.HResult == HResultRecognizerNotFound)
{
throw new Exception("Speech Language pack for selected language not installed.", ex);
}
else
{
throw;
}
}
}
async Task RecordSpeechFromMicrophoneAsync(VoiceInformation voiceInformation, Func <SpeechRecognitionResult, Task> doNext)
{
if (!await AudioCapturePermissions.RequestMicrophonePermission())
{
return;
}
if (voiceInformation == null)
{
return;
}
if (!await DoRecognition())
{
//media.StopMedia();
//In some cases DoRecognition ends prematurely e.g. when
//the user allows access to the microphone but there is no
//microphone available so do not stop media.
await SpeakAndListen();
}
async Task <bool> DoRecognition()
{
using (SpeechRecognizer speechRecognizer = new SpeechRecognizer(new Windows.Globalization.Language(voiceInformation.Language)))
{
SpeechRecognitionConstraints.ToList().ForEach(c => speechRecognizer.Constraints.Add(c));
speechRecognizer.Timeouts.InitialSilenceTimeout = TimeSpan.FromSeconds(SpeechRecognitionConstants.InitialSilenceTimeout);
speechRecognizer.Timeouts.EndSilenceTimeout = TimeSpan.FromSeconds(SpeechRecognitionConstants.EndSilenceTimeout);
await speechRecognizer.CompileConstraintsAsync();
SpeechRecognitionResult result = await speechRecognizer.RecognizeAsync();
if (
!(result.Status == SpeechRecognitionResultStatus.Success &&
new HashSet <SpeechRecognitionConfidence>
{
SpeechRecognitionConfidence.High,
SpeechRecognitionConfidence.Medium,
SpeechRecognitionConfidence.Low
}.Contains(result.Confidence)
)
)
{
return(false);
}
if (result.Constraint.Tag == SpeechRecognitionConstants.GOBACKTAG)
{
if (UiNotificationService.CanGoBack)
{
await GoBack();
return(true);
}
else
{
return(false);
}
}
else
{//Options constraint succeeded
await doNext(result);
return(true);
}
}
}
}