Audio Recorder In Windows 10 Universal Windows Platform

We can easily record the audio in Windows 10 universal app using media MediaCapture class.

Let’s see the steps,

Create new Windows 10 universal app project and go to design page to design the UI as you want. Here I will create application bar with three buttons: one for record, one is for stop and another one is for playing the recorded audio.

Use the following XAML Code for design.

<Page.BottomAppBar>
    <AppBar IsOpen="True" IsSticky="True">
        <StackPanel Orientation="Horizontal">
            <AppBarButton x:Name="recordBtn" Label="Record" Icon="Microphone" Click="recordBtn_Click"></AppBarButton>
            <AppBarButton x:Name="stopBtn" Label="Stop" Icon="Stop" Click="stopBtn_Click"></AppBarButton>
            <AppBarButton x:Name="playBtn" Label="Play" Icon="Play" Click="playBtn_Click"></AppBarButton>
        </StackPanel>
    </AppBar>
</Page.BottomAppBar>

Firstly, we need to enable capabilities of Microphone in “Package.appxmanifest” file like the following image.

 

Now go to code behind and write the following code.

Create instance for MediaCapture and memory stream then set media capture settings to record audio or video.

Finally, start the record using StartRecordToStreamAsync method by passing media profile and buffer.

You can stop the recording by using StopRecordAsync method.

For playing this recording file we use MediaElement Control.

C# code

public sealed partial class MainPage: Page
{
    MediaCapture capture;
    InMemoryRandomAccessStream buffer;
    bool record;
    string filename;
    string audioFile = ".MP3";
    public MainPage()
    {
        this.InitializeComponent();
    }

    private async Task < bool > RecordProcess()
    {
        if (buffer != null)
        {
            buffer.Dispose();
        }
        buffer = new InMemoryRandomAccessStream();
        if (capture != null)
        {
            capture.Dispose();
        }
        try
        {
            MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings
            {
                StreamingCaptureMode = StreamingCaptureMode.Audio
            };
            capture = new MediaCapture();
            await capture.InitializeAsync(settings);
            capture.RecordLimitationExceeded += (MediaCapture sender) =>
            {
                //Stop
                // await capture.StopRecordAsync();
                record = false;
                throw new Exception("Record Limitation Exceeded ");
            };
            capture.Failed += (MediaCapture sender, MediaCaptureFailedEventArgs errorEventArgs) =>
            {
                record = false;
                throw new Exception(string.Format("Code: {0}. {1}", errorEventArgs.Code, errorEventArgs.Message));
            };
        } catch (Exception ex)
        {
            if (ex.InnerException != null && ex.InnerException.GetType() == typeof(UnauthorizedAccessException)) {
                throw ex.InnerException;
            }
            throw;
        }
        return true;
    }
    public async Task PlayRecordedAudio(CoreDispatcher UiDispatcher)
    {
        MediaElement playback = new MediaElement();
        IRandomAccessStream audio = buffer.CloneStream();

        if (audio == null)
            throw new ArgumentNullException("buffer");
        StorageFolder storageFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
        if (!string.IsNullOrEmpty(filename))
        {
            StorageFile original = await storageFolder.GetFileAsync(filename);
            await original.DeleteAsync();
        }
        await UiDispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
       {
            StorageFile storageFile = await storageFolder.CreateFileAsync(audioFile, CreationCollisionOption.GenerateUniqueName);
            filename = storageFile.Name;
            using(IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite)) {
                await RandomAccessStream.CopyAndCloseAsync(audio.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0));
                await audio.FlushAsync();
                audio.Dispose();
            }
            IRandomAccessStream stream = await storageFile.OpenAsync(FileAccessMode.Read);
            playback.SetSource(stream, storageFile.FileType);
            playback.Play();
        });
    }
    private async void recordBtn_Click(object sender, RoutedEventArgs e)
    {
        if (record)
        {
            //already recored process
        } else
        {
            await RecordProcess();
            await capture.StartRecordToStreamAsync(MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto), buffer);
            if (record)
            {
                throw new InvalidOperationException();
            }
            record = true;
        }

    }

    private async void stopBtn_Click(object sender, RoutedEventArgs e)
    {
        await capture.StopRecordAsync();
        record = false;
    }

    private async void playBtn_Click(object sender, RoutedEventArgs e)
    {
        await PlayRecordedAudio(Dispatcher);
    }
}

Now run the app and see the expected output like the following image.



For Source Code.