private async void StartStreams()
{
this.sensorClient = new ClientSensor();
var streamTasks = new List <Task>
{
this.StartAccelerometerStream(),
this.StartHeartRateStream(),
this.StartSkinTemperatureStream(),
this.StartContactStream(),
this.StartPedometerStream(),
this.StartUVIndexStream(),
this.StartCaloriesStream(),
this.StartGSRStream(),
this.StartAmbientLightStream(),
this.StartAltimeterStream(),
this.StartBarometerStream(),
this.StartRRIntervalStream()
};
try
{
await Task.WhenAll(streamTasks);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
await c.saveStringToLocalFile("DebugLogs.txt", "TimeStamp: " + BandController.CurrentDate() + " Debug: " + "Connecting to the Sensors - " + ex.Message);
}
}
private async Task StartUVIndexStream()
{
var stream = await this.GetSensorStream(this.bandClient.SensorManager.UV);
if (stream == null)
{
return;
}
this.disposableStreams.Add(stream.Subscribe());
var channelName = $"{nameof(this.bandClient.SensorManager.UV)}Index";
//var channelCode = this.channels[channelName];
await stream.Buffer(new TimeSpan(0, 0, Interval)).Select(
async readings =>
{
if (!readings.Any())
{
return;
}
var indexLevel =
readings.GroupBy(reading => reading.SensorReading.IndexLevel)
.OrderByDescending(gr => gr.Count())
.Select(gr => gr.Key)
.First();
var sample = new SensorReadingDC(channelName, BandController.GetUnixTimeStamp(), indexLevel.ToString());
//var sampleValue = new DataSampleDC
//{
// SensorType = channelCode,
// Values = new Dictionary<string, string>
// { { channelCode, indexLevel.ToString() } }
//};
await this.SendNewSample(sample);
});
}
private async Task StartContactStream()
{
var stream = await this.GetSensorStream(this.bandClient.SensorManager.Contact);
if (stream == null)
{
return;
}
this.disposableStreams.Add(stream.Subscribe());
var channelName = nameof(this.bandClient.SensorManager.Contact);
//var channelCode = this.channels[channelName];
await stream.Buffer(new TimeSpan(0, 0, Interval)).Select(
async readings =>
{
if (!readings.Any())
{
return;
}
var worn = readings.All(reading => reading.SensorReading.State == BandContactState.Worn);
var sample = new SensorReadingDC(channelName, BandController.GetUnixTimeStamp(), worn.ToString());
//var sampleValue = new DataSampleDC
//{
// SensorType = channelCode,
// Values = new Dictionary<string, string>
// { { channelCode, worn.ToString() } }
//};
await this.SendNewSample(sample);
});
}
public void MethodToTest()
{
// Arange
var listOfBands = new List <Band>();
listOfBands.Add(new Band {
Name = "Rush",
Origin = "Toronto, Canada",
Genre = "ProgRock",
BestSong = "Red Barchetta"
});
Mock <IRepository> mockRepository = new Mock <IRepository>();
mockRepository.Setup(x => x.GetBands()).Returns(listOfBands);
// Act
var bandController = new BandController(mockRepository.Object);
bandController.MethodToTest();
// Assert fluid
bandController.Should().NotBeNull();
listOfBands.Count.Should().Be(1);
listOfBands[0].Name.Should().Be("Rush");
// Assert standard
Assert.IsNotNull(bandController);
Assert.AreEqual(expected: 1, actual: listOfBands.Count);
Assert.AreEqual(expected: "Rush", actual: listOfBands[0].Name);
}
private async void RemoveTile()
{
try
{
// get the current set of tiles
IEnumerable <BandTile> tiles = await bandClient.TileManager.GetTilesAsync();
foreach (var t in tiles)
{
// remove the tile from the Band
if (await bandClient.TileManager.RemoveTileAsync(t))
{
// do work if the tile was successfully removed
MessageDialog msg = new MessageDialog("Tile removed.");
await msg.ShowAsync();
}
else
{
MessageDialog msg = new MessageDialog("Failure at removing the tile.");
await msg.ShowAsync();
}
}
}
catch (BandException ex)
{
Debug.WriteLine(ex.Message);
await c.saveStringToLocalFile("DebugLogs.txt", "TimeStamp: " + BandController.CurrentDate() + " Debug: " + "Removing Tile - " + ex.Message);
}
}
private void RabbitPublisher()
{
var connectionFactory = new ConnectionFactory();
connectionFactory.HostName = "localhost";
connectionFactory.UserName = "******";
connectionFactory.Password = "******";
try
{
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare("WBA_HealthStatus_Trigger", "fanout");
String fullmsg = "Band," + BandController.GetUnixTimeStamp() + "," + heartbeatmed;
var body = Encoding.UTF8.GetBytes(fullmsg);
channel.BasicPublish("WBA_HealthStatus_Trigger_Response", "", null, body);
channel.Close();
}
}
catch (Exception)
{
// do stuff
}
}
private async Task StartRRIntervalStream()
{
var stream = await this.GetSensorStream(this.bandClient.SensorManager.RRInterval);
if (stream == null)
{
return;
}
this.disposableStreams.Add(stream.Subscribe());
var channelName = nameof(this.bandClient.SensorManager.RRInterval);
//var channelCode = this.channels[channelName.ToUpper()];
await stream.Buffer(new TimeSpan(0, 0, Interval)).Select(
async readings =>
{
if (!readings.Any())
{
return;
}
var rr = readings.Average(reading => reading.SensorReading.Interval);
var sample = new SensorReadingDC(channelName, BandController.GetUnixTimeStamp(), rr.ToString(CultureInfo.InvariantCulture));
//var sampleValue = new DataSampleDC
//{
// SensorType = channelCode,
// Values = new Dictionary<string, string>
// { { channelCode, gsr.ToString(CultureInfo.InvariantCulture) } }
//};
await this.SendNewSample(sample);
});
}
public MainPage()
{
this.InitializeComponent();
localFolderBox.Text = Windows.Storage.ApplicationData.Current.LocalFolder.Path;
c = new BandController();
//c.waitForLogin();
Loaded += OnLoaded;
}
private BandManager(int interv, int classAmount)
{
this.channels = new Dictionary <string, string>();
this.disposableStreams = new List <IDisposable>();
this.sentNewValue = false;
c = new BandController();
this.Interval = interv;
this.classifierAmount = classAmount;
}
private async Task <bool> AddTile()
{
try
{
// Create the small and tile icons from writable bitmaps.
// Small icons are 24x24 pixels.
//WriteableBitmap smallIconBitmap = new WriteableBitmap(24, 24);
//BandIcon smallIcon = smallIconBitmap.ToBandIcon();
//// Tile icons are 46x46 pixels for Microsoft Band 1, and 48x48 pixels
//// for Microsoft Band 2.
//WriteableBitmap tileIconBitmap = new WriteableBitmap(46, 46);
//BandIcon tileIcon = tileIconBitmap.ToBandIcon();
int version = Convert.ToInt32(bandVersion);
if (version <= 19)
{
BandIcon tileIcon = await ConvertIMG("ms-appx:///Assets/46x46.png");
BandIcon smallIcon = await ConvertIMG("ms-appx:///Assets/24x24.png");
}
else
{
BandIcon tileIcon = await ConvertIMG("ms-appx:///Assets/48x48.png");
BandIcon smallIcon = await ConvertIMG("ms-appx:///Assets/24x24.png");
}
var myTile = new BandTile(myTileId)
{
IsBadgingEnabled = true,
Name = "MS Band Data Collection",
//TileIcon = tileIcon,
//SmallIcon = smallIcon
TileIcon = tileIcon,
SmallIcon = smallIcon
};
// Remove the Tile from the Band, if present. An application won't need to do this everytime it runs.
// But in case you modify this sample code and run it again, let's make sure to start fresh.
//await bandClient.TileManager.RemoveTileAsync(myTileId);
// Create the Tile on the Band.
await bandClient.TileManager.AddTileAsync(myTile);
// Subscribe to Tile events.
}
catch (Exception ex)
{
Debug.WriteLine("Error on adding a tile to the band: " + ex);
await c.saveStringToLocalFile("DebugLogs.txt", "TimeStamp: " + BandController.CurrentDate() + " Debug: " + " Error on adding a tile to the band - " + ex);
}
return(false);
}
private async Task StartAccelerometerStream()
{
var stream = await this.GetSensorStream(this.bandClient.SensorManager.Accelerometer);
if (stream == null)
{
return;
}
this.disposableStreams.Add(stream.Subscribe());
var channelName = nameof(this.bandClient.SensorManager.Accelerometer);
////var channelCodes = new List<string>
////{
//// this.channels[$"{channelName}X"],
//// this.channels[$"{channelName}Y"],
//// this.channels[$"{channelName}Z"]
////};
//var sensorType = channelCodes[0].Split('-').FirstOrDefault();
await stream.Buffer(new TimeSpan(0, 0, HighOutputInterval)).Select(
async readings =>
{
var accelerationX = string.Join(Separator,
readings.Select(
reading => reading.SensorReading.AccelerationX.ToString(CultureInfo.InvariantCulture)));
var accelerationY = string.Join(Separator,
readings.Select(
reading => reading.SensorReading.AccelerationY.ToString(CultureInfo.InvariantCulture)));
var accelerationZ = string.Join(Separator,
readings.Select(
reading => reading.SensorReading.AccelerationZ.ToString(CultureInfo.InvariantCulture)));
if (string.IsNullOrEmpty(accelerationX) &&
string.IsNullOrEmpty(accelerationY) &&
string.IsNullOrEmpty(accelerationZ))
{
return;
}
var message = accelerationX + " , " + accelerationY + " , " + accelerationZ;
var sample = new SensorReadingDC(channelName, BandController.GetUnixTimeStamp(), message);
//var sampleValues = new DataSampleDC
//{
// SensorType = sensorType,
// Values = new Dictionary<string, string>
// {
// { channelCodes[0], accelerationX.ToString() },
// { channelCodes[1], accelerationY.ToString() },
// { channelCodes[2], accelerationZ.ToString() }
// }
//};
await this.SendNewSample(sample);
});
}
private async void CheckCaloriesCycle()
{
var Calstream = await bandHelper.GetTotalCal();
long currCal = await Calstream.FirstAsync();
long diff = currCal - totalCal;
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
CaloriesDisplay.Text = " Calories: " + diff;
await c.saveStringToLocalFile(BandController.CurrentDateForFile() + "-BandCalLogs.txt", "TimeStamp: " + BandController.GetUnixTimeStamp() + CaloriesDisplay.Text);
}).AsTask();
}
private async Task InitAsync()
{
try
{
this.selectedBand = await this.FindDevicesAsync();
if (this.selectedBand == null)
{
return;
}
this.bandClient = await this.ConnectAsync();
if (this.bandClient == null)
{
return;
}
//await this.LoadBandRegistrySensor();
//if (this.bandRegistrySensor == null)
//{
// return;
//}
//RemoveTile();
bandVersion = await this.bandClient.GetHardwareVersionAsync();
AddingTile();
this.StartStreams();
StartConnectionChecker();
}
catch (Exception x)
{
Debug.WriteLine(x.Message);
await c.saveStringToLocalFile("DebugLogs.txt", "TimeStamp: " + BandController.CurrentDate() + " Debug: " + "Connecting to the Band - " + x.Message);
}
finally
{
this.initializingTask = null;
}
}
public void MethodTest()
{
var listOfBands = new List <Band>();
listOfBands.Add(new Band
{
Name = "Insync Maniacs",
song = "Fir Kabhi",
genre = "emotional"
});
Mock <IRepository> mockRepository = new Mock <IRepository>();
mockRepository.Setup(x => x.GetBands()).Returns(listOfBands);
var bandController = new BandController(mockRepository.Object);
bandController.Method();
bandController.Should().NotBeNull();
}
public void Should_Return_ListOfBands()
{
Mock <IRepository> mockRepository = new Mock <IRepository>();
var listOfBands = new List <Band>();
listOfBands.Add(new Band {
Name = "Bayside", Origin = "Queens, New York", Genre = "Alternative", BestSong = "I And I"
});
mockRepository.Setup(p => p.GetBands()).Returns(listOfBands);
var controller = new BandController(mockRepository.Object);
controller.Should().NotBeNull();
var result = controller.GetBands();
result.Should().Equal(listOfBands);
}
public void MethodToTest()
{
// CREATE LIST OF BANDS TO RETURN
var ListofBands = new List <Band>();
ListofBands.Add(new Band
{
Name = "Uzay",
Origin = "İzmir",
Genre = "Rock",
BestSong = "Sabır"
});
Mock <IRepository> mockRepository = new Mock <IRepository>();
mockRepository.Setup(x => x.GetBands()).Returns(ListofBands);
var bandController = new BandController(mockRepository.Object);
bandController.MethodToTest();
bandController.Should().NotBeNull();
}
private async Task StartHeartRateStream()
{
var stream = await this.GetSensorStream(this.bandClient.SensorManager.HeartRate);
if (stream == null)
{
return;
}
this.disposableStreams.Add(stream.Subscribe());
var channelName = nameof(this.bandClient.SensorManager.HeartRate);
//var channelCode = this.channels[channelName];
await stream.Buffer(new TimeSpan(0, 0, Interval)).Select(
async readings =>
{
var lockedReadings =
readings.Where(reading => reading.SensorReading.Quality == HeartRateQuality.Locked);
if (!lockedReadings.Any())
{
return;
}
var avg = lockedReadings.Average(reading => reading.SensorReading.HeartRate);
var min = lockedReadings.Min(y => y.SensorReading.HeartRate);
var max = lockedReadings.Max(y => y.SensorReading.HeartRate);
var avgdouble = Math.Round(avg, 2);
var message = min.ToString() + " , " + avgdouble.ToString() + " , " + max.ToString();
var sample = new SensorReadingDC(channelName, BandController.GetUnixTimeStamp(), message);
//var sampleValue = new DataSampleDC
//{
// SensorType = channelCode,
// Values = new Dictionary<string, string>
// { { channelCode, avg.ToString(CultureInfo.InvariantCulture) } }
//};
await this.SendNewSample(sample);
});
}
private async Task StartPedometerStream()
{
var stream = await this.GetSensorStream(this.bandClient.SensorManager.Pedometer);
if (stream == null)
{
return;
}
this.disposableStreams.Add(stream.Subscribe());
var channelName = nameof(this.bandClient.SensorManager.Pedometer);
//var channelCode = this.channels[channelName];
await stream.Buffer(new TimeSpan(0, 0, Interval)).Select(
async readings =>
{
if (!readings.Any())
{
return;
}
var steps = readings.Max(reading => reading.SensorReading.TotalSteps);
if (isFirstStepsReading)
{
isFirstStepsReading = false;
firstStepsReading = steps;
}
var sample = new SensorReadingDC(channelName, BandController.GetUnixTimeStamp(),
(steps - firstStepsReading).ToString(CultureInfo.InvariantCulture));
//var sampleValue = new DataSampleDC
//{
// SensorType = channelCode,
// Values = new Dictionary<string, string>
// { { channelCode, (steps - firstStepsReading).ToString(CultureInfo.InvariantCulture) } }
//};
await
this.SendNewSample(sample);
});
}
//private async Task LoadBandRegistrySensor()
//{
// var client = new ClientRegistryPeople();
// try
// {
// var personalSensors = await client.ListPersonalSensorsAsync(this.currentCredentials);
// this.bandRegistrySensor =
// personalSensors.FirstOrDefault(
// registrySensor => registrySensor.ExtraData["HardwareAddress"] == this.selectedBand.Name);
// if (this.bandRegistrySensor == null)
// {
// return;
// }
// foreach (string channelCode in this.bandRegistrySensor.ExtraData["DataChannels"])
// {
// string channelName;
// if (!FHIRDefinitions.Instance.FHIRToSensorTypes.TryGetValue(channelCode, out channelName))
// {
// continue;
// }
// this.channels.Add(channelName, channelCode);
// }
// }
// catch (Exception ex)
// {
// Debug.WriteLine(ex);
// }
// finally
// {
// client.Dispose();
// }
//}
private async void AddingTile()
{
try
{
IEnumerable <BandTile> tile = await GetTiles();
var capacity = await bandClient.TileManager.GetRemainingTileCapacityAsync();
if (tile != null)
{
if (capacity != 0)
{
await AddTile();
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
await c.saveStringToLocalFile("DebugLogs.txt", "TimeStamp: " + BandController.CurrentDate() + " Debug: " + "Adding Tile - " + ex.Message);
}
}
public async void SendMessage(string message)
{
var notifictionManager = bandClient.NotificationManager;
//IEnumerable<BandTile> tiles = await GetTiles();
//var tileId = tiles.GetEnumerator().Current.TileId;
try
{
await notifictionManager.VibrateAsync(VibrationType.ThreeToneHigh);
await notifictionManager.ShowDialogAsync(
myTileId,
"WBA Alert - High HR",
"Please take a break"
);
await notifictionManager.SendMessageAsync(
myTileId,
"WBA Alert - High HR",
"Average HR: " + message,
DateTimeOffset.Now);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
await c.saveStringToLocalFile("DebugLogs.txt", "TimeStamp: " + BandController.CurrentDate() + " Debug: " + "Tile Send Message feature - " + ex.Message);
}
// send a notification to the Band with a dialog as well as a page
//await notifictionManager.SendMessageAsync(
// tileId,
// "Message Title",
// "This is the message body...",
// DateTime.Now,
// true);
}
private async void ManageBand(BandReativeExtensionsWrapper bandHelper)
{
bandHelper.SendMessage("Testing Messages");
var streamHR = await bandHelper.GetHeartRateStream();
var streamCal = await bandHelper.GetCaloriesStream();
var streamSkin = await bandHelper.GetSkinTemperatureStream();
var streamUV = await bandHelper.GetUltravioletStream();
var streamPed = await bandHelper.GetPedometerStream();
var streamAcce = await bandHelper.GetAccelerometerStream();
var currCalstream = await bandHelper.GetTotalCal();
totalCal = await currCalstream.FirstAsync();
await c.saveStringToLocalFile(BandController.CurrentDateForFile() + "-BandCalLogs.txt", "TimeStamp: " + BandController.GetUnixTimeStamp() + "Ciclo de trabalho iniciado. Calorias desde o ultimo factory reset: " + totalCal);
var hrSubscription = streamHR
.Where(x => x.SensorReading.Quality == Microsoft.Band.Sensors.HeartRateQuality.Locked)
.Buffer(new TimeSpan(0, 0, interv))
.Select(async x =>
{
var avg = x.Average(y => y.SensorReading.HeartRate);
var min = x.Min(y => y.SensorReading.HeartRate);
var max = x.Max(y => y.SensorReading.HeartRate);
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
HeartRateDisplay.Text = " HeartRate Med: " + Math.Round(avg, 2) + " Min: " + min + " Max: " + max;
await c.saveStringToLocalFile(BandController.CurrentDateForFile() + "-BandHRLogs.txt", "TimeStamp: " + BandController.GetUnixTimeStamp() + HeartRateDisplay.Text);
}).AsTask();
return(avg);
})
.Subscribe(x =>
{
Debug.WriteLine(x);
if (x.IsFaulted)
{
btrange = true;
}
});
//var calSubscription = streamCal
// .Where(x => x.SensorReading.Calories != 0)
// .Buffer(new TimeSpan(0, 0, interv))
// .Select(async x =>
// {
// var value = x.Select(y => y.SensorReading.Calories);
// long cal = value.Last() - totalCal;
// await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
// {
// CaloriesDisplay.Text = "Calories: " + cal;
// await c.saveStringToLocalFile(BandController.CurrentDateForFile() + "-BandCalLogs.txt", "TimeStamp: " + BandController.GetUnixTimeStamp() + CaloriesDisplay.Text);
// }).AsTask();
// return cal;
// })
// .Subscribe(x =>
// {
// Debug.WriteLine(x);
// });
var skinSubscription = streamSkin
.Buffer(new TimeSpan(0, 0, interv))
.Select(async x =>
{
var avg = x.Average(y => y.SensorReading.Temperature);
var min = x.Min(y => y.SensorReading.Temperature);
var max = x.Max(y => y.SensorReading.Temperature);
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
SkinTemperatureDisplay.Text = " Temperature Med: " + Math.Round(avg, 2) + " Min: " + min + " Max: " + max;
await c.saveStringToLocalFile(BandController.CurrentDateForFile() + "-BandTemperatureLogs.txt", "TimeStamp: " + BandController.GetUnixTimeStamp() + SkinTemperatureDisplay.Text);
}).AsTask();
return(avg);
})
.Subscribe(x =>
{
Debug.WriteLine(x);
});
//var pedSubscription = streamPed
// .Buffer(new TimeSpan(0, 0, interv))
// .Select(async x =>
// {
// var total = x.Select(y => y.SensorReading.TotalSteps);
// await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
// {
// PedometerDisplay.Text = "Steps: " + total;
// await c.saveStringToLocalFile(BandController.CurrentDateForFile() + "-BandStepsLogs.txt", "TimeStamp: " + BandController.GetUnixTimeStamp() + PedometerDisplay.Text);
// }).AsTask();
// return total;
// })
// .Subscribe(x =>
// {
// Debug.WriteLine(x);
// });
//var uvSubscription = streamUV
// .Buffer(new TimeSpan(0, 0, interv))
// .Select(async x =>
// {
// var index = x.Select(y => y.SensorReading.IndexLevel);
// await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
// {
// UVDisplay.Text = " UV: " + index.Last().ToString();
// await c.saveStringToLocalFile(BandController.CurrentDateForFile() + "-BandUVLogs.txt", "TimeStamp: " + BandController.GetUnixTimeStamp() + UVDisplay.Text);
// }).AsTask();
// return index;
// })
// .Subscribe(x =>
// {
// Debug.WriteLine(x);
// });
//var accSubscription = streamAcce
// .Buffer(new TimeSpan(0, 0, interv))
// .Select(async x =>
// {
// var pointX = x.Select(y => y.SensorReading.AccelerationX);
// var pointY = x.Select(y => y.SensorReading.AccelerationY);
// var pointZ = x.Select(y => y.SensorReading.AccelerationZ);
// await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
// {
// AcceDisplay.Text = "Point X: " + pointX + " Point Y: " + pointY + " PointZ: " + pointZ;
// await c.saveStringToLocalFile(BandController.CurrentDateForFile() + "-BandAccellLogs.txt", "TimeStamp: " + BandController.GetUnixTimeStamp() + AcceDisplay.Text);
// }).AsTask();
// return pointX;
// })
// .Subscribe(x =>
// {
// Debug.WriteLine(x);
// });
//var streamAcc
//if (_bandClient != null)
// return;
//var bands = await BandClientManager.Instance.GetBandsAsync();
//_bandInfo = bands.First();
//_bandClient = await BandClientManager.Instance.ConnectAsync(_bandInfo);
//var uc = _bandClient.SensorManager.HeartRate.GetCurrentUserConsent();
//bool isConsented = false;
//if (uc == UserConsent.NotSpecified)
//{
// isConsented = await _bandClient.SensorManager.HeartRate.RequestUserConsentAsync();
//}
//if (isConsented || uc == UserConsent.Granted)
//{
// IEnumerable<TimeSpan> supportedHeartBeatReportingIntervals = _bandClient.SensorManager.HeartRate.SupportedReportingIntervals;
// foreach(var ri in supportedHeartBeatReportingIntervals)
// {
// }
// _bandClient.SensorManager.HeartRate.ReadingChanged += async (obj, ev) =>
// {
// await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
// {
// HeartRateDisplay.Text = ev.SensorReading.HeartRate.ToString();
// HeartRateState.Text = ev.SensorReading.Quality.ToString();
// //await c.saveStringToLocalFile("BandHRLogs.txt", "HeartRate: " + ev.SensorReading.HeartRate);
// }).AsTask();
// };
// await _bandClient.SensorManager.HeartRate.StartReadingsAsync();
//}
}
private async void StartLogs()
{
await c.saveStringToLocalFile("BandHRLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandSkinTempLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandContactLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandPedometerLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandUVLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandCaloriesLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandGsrLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandAmbientLightLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandAltimeterLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandBarometerLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
await c.saveStringToLocalFile("BandRRIntervalLogs.txt", "----- Application started at " + BandController.CurrentDate() + " ---");
}
static void Main(string[] args)
{
var concreteRepository = new Repository();
var example = new BandController(concreteRepository);
}
