private async Task ConnectAsyncInternal()
{
_tokenSource = new CancellationTokenSource();
string selector = RfcommDeviceService.GetDeviceSelector(RfcommServiceId.SerialPort);
DeviceInformationCollection devices = await DeviceInformation.FindAllAsync(selector);
DeviceInformation device = (from d in devices where d.Name == _deviceName select d).FirstOrDefault();
if (device == null)
{
ThrowException($"LEGO EV3 brick named '{_deviceName}' not found.");
}
RfcommDeviceService service = await RfcommDeviceService.FromIdAsync(device.Id);
if (service == null)
{
ThrowException("Unable to connect to LEGO EV3 brick... Is the manifest set properly ?");
}
_socket = new StreamSocket();
await _socket.ConnectAsync(
service.ConnectionHostName,
service.ConnectionServiceName,
SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication);
_reader = new DataReader(_socket.InputStream)
{
ByteOrder = ByteOrder.LittleEndian
};
await WindowThreadPool.RunAsync(async (_) => await PollInputAsync());
}
private async Task ConnectAsyncInternal(HostName hostName)
{
_tokenSource = new CancellationTokenSource();
_socket = new StreamSocket();
// connect to the brick on port 5555
await _socket.ConnectAsync(hostName, "5555", SocketProtectionLevel.PlainSocket);
// unlock the brick (doesn't actually need serial number?)
await _socket.OutputStream.WriteAsync(Encoding.UTF8.GetBytes(UnlockCommand).AsBuffer());
// read the "Accept:EV340\r\n\r\n" response
IBuffer bufferResponse = new Buffer(128);
await _socket.InputStream.ReadAsync(bufferResponse, bufferResponse.Capacity, InputStreamOptions.Partial);
string response = Encoding.UTF8.GetString(bufferResponse.ToArray(), 0, (int)bufferResponse.Length);
if (string.IsNullOrEmpty(response))
{
throw new Exception("LEGO EV3 brick did not respond to the unlock command.");
}
await ThreadPool.RunAsync(PollInput);
}
private static async Task MoveFolderIterate(List <Folder> list, int folderID, StorageFolder destination,
CancellationToken cancellationToken, IProgress <double> progress)
{
var rootFolder = list.Find(folder => folder.ID == folderID);
foreach (var file in rootFolder.Files)
{
var properties = await file.GetBasicPropertiesAsync();
var fileSize = properties.Size;
await file.MoveAsync(destination);
await ThreadPool.RunAsync(delegate
{
_finishedSize += fileSize;
progress.Report(_finishedSize / (double)_totalSize * 100.0);
});
}
var subFolders = list.FindAll(folder => folder.ParentFolderID == folderID);
if (!subFolders.Any())
{
return;
}
foreach (var folder in subFolders)
{
if (cancellationToken.IsCancellationRequested)
{
break;
}
var newFolder = await destination.CreateFolderAsync(folder.Name);
await MoveFolderIterate(list, folder.ID, newFolder, cancellationToken, progress);
}
}
public async Task ConnectAsync()
{
_tokenSource = new CancellationTokenSource();
PeerFinder.AlternateIdentities["Bluetooth:Paired"] = "";
IReadOnlyList <PeerInformation> peers = await PeerFinder.FindAllPeersAsync();
PeerInformation peer = (from p in peers where p.DisplayName == _deviceName select p).FirstOrDefault();
if (peer == null)
{
throw new Exception(_deviceName + " Brick not found");
}
_socket = new StreamSocket();
await _socket.ConnectAsync(peer.HostName, "1");
_reader = new DataReader(_socket.InputStream);
_reader.ByteOrder = ByteOrder.LittleEndian;
//¿qué hacía esto en wp 8.0?
//ThreadPool.QueueUserWorkItem(PollInput);
await ThreadPool.RunAsync(PollInput);
}
private static async Task CopyFolderIterate(List <Folder> list, int folderID, StorageFolder destination,
CancellationToken cancellationToken, IProgress <double> progress)
{
var rootFolder = list.Find(folder => folder.ID == folderID);
foreach (var file in rootFolder.Files)
{
var buffer = new byte[MaxBufferSize];
var readStream = await file.OpenStreamForReadAsync();
var writeFile = await destination.CreateFileAsync(file.Name);
var writeStream = await writeFile.OpenStreamForWriteAsync();
while (true)
{
int buffersize;
buffersize = (readStream.Length - readStream.Position) < MaxBufferSize
? (int)(readStream.Length - readStream.Position)
: MaxBufferSize;
var readSize = readStream.Read(buffer, 0, buffersize);
if (readSize > 0)
{
writeStream.Write(buffer, 0, buffersize);
await ThreadPool.RunAsync(delegate
{
_finishedSize += (ulong)buffersize;
progress.Report(_finishedSize / (double)_totalSize * 100.0);
});
}
else
{
break;
}
}
readStream.Close();
writeStream.Close();
}
var subFolders = list.FindAll(folder => folder.ParentFolderID == folderID);
if (!subFolders.Any())
{
return;
}
foreach (var folder in subFolders)
{
if (cancellationToken.IsCancellationRequested)
{
break;
}
var newFolder = await destination.CreateFolderAsync(folder.Name);
await CopyFolderIterate(list, folder.ID, newFolder, cancellationToken, progress);
}
}
/// <summary>
/// Initializes a thread and starts pinging the specified server
/// Calculates the ping and delta of each ping in ms
/// </summary>
public void StartPing(int numberOfPings)
{
_isRunning = true;
_totalTime = 0;
IAsyncAction _pingAction = ThreadPool.RunAsync(async workItem => {
var previousPingTime = 0;
var delta = 0;
var pingIteration = 1;
while (pingIteration <= numberOfPings && _isRunning)
{
var stopwatch = new Stopwatch();
var socket = new StreamSocket();
stopwatch.Start();
try
{
await socket.ConnectAsync(new HostName(_url), "80");
} catch (Exception e)
{
OnThreadFinished(FinishType.ERROR);
OnThreadFinished(FinishType.FINISHED);
return;
}
stopwatch.Stop();
var ms = (int)stopwatch.ElapsedMilliseconds;
// First time there is no delta
if (pingIteration > 0)
{
delta = Math.Abs(ms - previousPingTime);
previousPingTime = ms;
}
Interlocked.Add(ref _totalTime, ms + delta);
HorseProgressEventArgs horseProgressEventArgs = new HorseProgressEventArgs(_totalTime, pingIteration);
OnPingReceived(horseProgressEventArgs);
Thread.Sleep(1000);
pingIteration++;
}
if (!_isRunning)
{
OnThreadFinished(FinishType.CANCELED);
return;
}
OnThreadFinished(FinishType.FINISHED);
});
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
_deferral = taskInstance.GetDeferral();
taskInstance.Canceled += OnTaskCanceled;
_source = new CancellationTokenSource();
_listener = new DeviceListener(
brick: new Brick(new CommunicationFactory(), new FileProvider()),
notify: NotifyMethodAsync
);
await ThreadPool.RunAsync(async _ =>
{
await _listener.ConnectAsync(_source.Token);
await _listener.InitializeAsync();
});
}