Dictation recogniser not working hololens

using HoloToolkit.Unity.InputModule;
using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Windows.Speech;
using System.Diagnostics;

public class MicrophoneManager : MonoBehaviour
{
[Tooltip("A text area for the recognizer to display the recognized strings.")]
public Text DictationDisplay;

private DictationRecognizer dictationRecognizer;

// Use this string to cache the text currently displayed in the text box.
private StringBuilder textSoFar;

// Using an empty string specifies the default microphone. 
private static string deviceName = string.Empty;
private int samplingRate;
private const int messageLength = 10;

// Use this to reset the UI once the Microphone is done recording after it was started.
private bool hasRecordingStarted;

void Start()
{



    dictationRecognizer = new DictationRecognizer();


    dictationRecognizer.DictationHypothesis += DictationRecognizer_DictationHypothesis;



    dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;



    dictationRecognizer.DictationComplete += DictationRecognizer_DictationComplete;


    // This event is fired when an error occurs.
    dictationRecognizer.DictationError += DictationRecognizer_DictationError;


    int unused;
    Microphone.GetDeviceCaps(deviceName, out unused, out samplingRate);


    textSoFar = new StringBuilder();


    hasRecordingStarted = false;
}

void Update()
{
    // 3.a: Add condition to check if dictationRecognizer.Status is Running
    if (hasRecordingStarted && !Microphone.IsRecording(deviceName) && dictationRecognizer.Status == SpeechSystemStatus.Running)
    {
        // Reset the flag now that we're cleaning up the UI.
        hasRecordingStarted = false;


    }
}


public void   StartRecording()
{
    System.Diagnostics.Debug.WriteLine("Start recording");
    UnityEngine.Debug.Log("Start recording");
    // 3.a Shutdown the PhraseRecognitionSystem. This controls the KeywordRecognizers
    PhraseRecognitionSystem.Shutdown();

    // 3.a: Start dictationRecognizer
    dictationRecognizer.Start();

    // 3.a Uncomment this line
    DictationDisplay.text = "Dictation is starting. It may take time to display your text the first time, but begin speaking now...";

    // Set the flag that we've started recording.
    hasRecordingStarted = true;

    // Start recording from the microphone for 10 seconds.
    Microphone.Start(deviceName, false, messageLength, samplingRate);
}

/// <summary>
/// Ends the recording session.
/// </summary>
public void StopRecording()
{
    // 3.a: Check if dictationRecognizer.Status is Running and stop it if so
    if (dictationRecognizer.Status == SpeechSystemStatus.Running)
    {
        dictationRecognizer.Stop();
    }

    Microphone.End(deviceName);
}

/// <summary>
/// This event is fired while the user is talking. As the recognizer listens, it provides text of what it's heard so far.
/// </summary>
/// <param name="text">The currently hypothesized recognition.</param>
private void DictationRecognizer_DictationHypothesis(string text)
{
    UnityEngine.Debug.Log("DictationHypothesis");
    System.Diagnostics.Debug.WriteLine("DictationHypothesis");
    // 3.a: Set DictationDisplay text to be textSoFar and new hypothesized text
    // We don't want to append to textSoFar yet, because the hypothesis may have changed on the next event
    DictationDisplay.text = textSoFar.ToString() + " " + text + "...";
}

/// <summary>
/// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here.
/// </summary>
/// <param name="text">The text that was heard by the recognizer.</param>
/// <param name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param>
private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence)
{
    UnityEngine.Debug.Log("DictationResult");
    System.Diagnostics.Debug.WriteLine("DictationResult");
    // 3.a: Append textSoFar with latest text
    textSoFar.Append(text + ". ");

    // 3.a: Set DictationDisplay text to be textSoFar
    DictationDisplay.text = textSoFar.ToString();
}

/// <summary>
/// This event is fired when the recognizer stops, whether from Stop() being called, a timeout occurring, or some other error.
/// Typically, this will simply return "Complete". In this case, we check to see if the recognizer timed out.
/// </summary>
/// <param name="cause">An enumerated reason for the session completing.</param>
private void DictationRecognizer_DictationComplete(DictationCompletionCause cause)
{
    UnityEngine.Debug.Log("DictationComplete");
    System.Diagnostics.Debug.WriteLine("DictationComplete");
    // If Timeout occurs, the user has been silent for too long.
    // With dictation, the default timeout after a recognition is 20 seconds.
    // The default timeout with initial silence is 5s seconds.
    if (cause == DictationCompletionCause.TimeoutExceeded)
    {
        Microphone.End(deviceName);

        DictationDisplay.text = "Dictation has timed out. Please press the record button again.";

    }
}

/// <summary>
/// This event is fired when an error occurs.
/// </summary>
/// <param name="error">The string representation of the error reason.</param>
/// <param name="hresult">The int representation of the hresult.</param>
private void DictationRecognizer_DictationError(string error, int hresult)
{
    // 3.a: Set DictationDisplay text to be the error string
    DictationDisplay.text = error + "\nHRESULT: " + hresult;
}

private IEnumerator RestartSpeechSystem(KeywordManager keywordToStart)
{
    while (dictationRecognizer != null && dictationRecognizer.Status == SpeechSystemStatus.Running)
    {
        yield return null;
    }

    keywordToStart.StartKeywordRecognizer();
}

}