Microsoft Band Wrapper to Stream sensor data to Reactive Extensions

DemoUsage.cs

var bandHelper = new BandReativeExtensionsWrapper();

stream = await bandHelper.GetHeartRateStream();

var hrSubscription = stream
           .Buffer(new TimeSpan(0, 0, 10))
           .Select(x =>
           {
               var avg = x.Average(y => y.SensorReading.HeartRate);
               return avg;
           })
           .Subscribe(x =>
           {
               Debug.WriteLine(x);
           });

FullWrapper.cs

using Microsoft.Band;
using Microsoft.Band.Sensors;
using Microsoft.Band.Tiles;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.UI.Popups;

namespace GripDev.Band
{
    class BandReativeExtensionsWrapper
    {
        public IBandClient Client;

        public async Task Connect()
        {
            try
            {
                // This method will throw an exception upon failure for a veriety of reasons,
                // such as Band out of range or turned off.
                var bands = await BandClientManager.Instance.GetBandsAsync();
                Client = await BandClientManager.Instance.ConnectAsync(bands[0]);

            }
            catch (Exception ex)
            {
                var t = new MessageDialog(ex.Message, "Failed to Connect").ShowAsync();
            }
        }

        public async Task<IObservable<BandSensorReadingEventArgs<IBandHeartRateReading>>> GetHeartRateStream()
        {
            return await GetSensorStream<IBandHeartRateReading>(Client.SensorManager.HeartRate);
        }

        public async Task<IObservable<BandSensorReadingEventArgs<IBandAccelerometerReading>>> GetAccelerometerStream()
        {
            return await GetSensorStream<IBandAccelerometerReading>(Client.SensorManager.Accelerometer);
        }

        public async Task<IObservable<BandSensorReadingEventArgs<T>>> GetSensorStream<T>(IBandSensor<T> manager) where T : IBandSensorReading
        {
            var consent = manager.GetCurrentUserConsent();
            if (consent != UserConsent.Granted)
            {
                await manager.RequestUserConsentAsync();
            }

            var supportedIntervals = manager.SupportedReportingIntervals;
            manager.ReportingInterval = supportedIntervals.First();

            var stream = CreateObservableFromSensorEvent<T>(manager);

            return stream;
        }



        private IObservable<BandSensorReadingEventArgs<T>> CreateObservableFromSensorEvent<T>(IBandSensor<T> manager) where T : IBandSensorReading
        {

            var obs = Observable.FromEvent<
                EventHandler<BandSensorReadingEventArgs<T>>,
                BandSensorReadingEventArgs<T>>
                (
                    handler =>
                    {
                        EventHandler<BandSensorReadingEventArgs<T>> kpeHandler = (sender, e) => handler(e);
                        return kpeHandler;
                    },
                    async x =>
                    {
                        manager.ReadingChanged += x;
                        await manager.StartReadingsAsync();
                    },
                    async x =>
                    {
                        manager.ReadingChanged -= x;
                        await manager.StopReadingsAsync();
                    }
                );
            return obs;
        }

    }
}