/// <summary>
        /// Starts service
        /// </summary>
        protected override void Start()
        {
            try
            {
                if (this.state == null)
                {
                    this.state = new SpeechRecognizerState();
                }

                InitializeKinectAudio();

                // Set up speech recognition engine
                if (this.state.IgnoreAudioInput)
                {
                    this.state.Recognizer.SetInputToNull();
                }
                else
                {
                    SetRecognizerInputToKinectMicArray();
                }

                // Register handlers for speech and beam events
                this.state.Recognizer.RecognizerUpdateReached   += RecognizerUpdateReachedHandler;
                this.state.Recognizer.LoadGrammarCompleted      += LoadGrammarCompletedHandler;
                this.state.Recognizer.SpeechDetected            += SpeechDetectedHandler;
                this.state.Recognizer.SpeechRecognized          += SpeechRecognizedHandler;
                this.state.Recognizer.SpeechRecognitionRejected += SpeechRecognitionRejectedHandler;
                this.kinectAudioSource.BeamAngleChanged         += BeamChangedHandler;
            }
            catch (Exception exception)
            {
                // Fatal exception during startup, shutdown service
                LogError(LogGroups.Activation, exception);

                if (null != this.state.Recognizer)
                {
                    this.state.Recognizer.Dispose();
                }

                DefaultDropHandler(new DsspDefaultDrop());

                return;
            }

            SpawnIterator(LoadGrammarOnStartup);
        }
        public IEnumerator <ITask> ReplaceHandler(Replace replace)
        {
            SpeechRecognizerState newState = replace.Body;

            #region Set up load grammar request, load grammar and on success store new grammar in state
            // Set up load grammar request
            LoadGrammarRequest loadRequest = new LoadGrammarRequest();
            loadRequest.GrammarType       = newState.GrammarType;
            loadRequest.SrgsFileLocation  = newState.SrgsFileLocation;
            loadRequest.DictionaryGrammar = newState.DictionaryGrammar;

            // Load new grammar
            SuccessFailurePort loadGrammarPort = new SuccessFailurePort();
            SpawnIterator <LoadGrammarRequest, SuccessFailurePort>(
                loadRequest,
                loadGrammarPort,
                LoadGrammar
                );

            // Check loading outcome
            yield return((Choice)loadGrammarPort);

            Exception exception = (Exception)loadGrammarPort;
            if (exception != null)
            {
                LogWarning(exception);
                replace.ResponsePort.Post(Fault.FromCodeSubcodeReason(
                                              W3C.Soap.FaultCodes.Receiver,
                                              DsspFaultCodes.OperationFailed,
                                              exception.Message
                                              ));
                yield break;
            }
            #endregion

            #region Check new state's IgnoreAudioInput flag and start recognition engine if necessary
            if (newState.IgnoreAudioInput != state.IgnoreAudioInput)
            {
                state.IgnoreAudioInput = newState.IgnoreAudioInput;
                if (state.IgnoreAudioInput)
                {
                    // Stop engine and switch to ignoring audio input
                    state.Recognizer.RecognizeAsyncCancel();
                    state.Recognizer.SetInputToNull();
                }
                else
                {
                    SetRecognizerInputToKinectMicArray();

                    // Because old state ignored audio input the engine is stopped, now that
                    // we switched to listening to audio input the engine needs to be started
                    if (state.Recognizer.Grammars.Count > 0)
                    {
                        state.Recognizer.RecognizeAsync(RecognizeMode.Multiple);
                    }
                }
            }
            #endregion

            SaveState(this.state);

            // Notify subscribers of state change
            replace.Body = this.state;
            SendNotification <Replace>(this.subMgrPort, replace);

            replace.ResponsePort.Post(DefaultReplaceResponseType.Instance);
        }