private async Task OnSliderValueChanged(int index, double newValue)
{
// for Cut mode
if (IsSliderActive[index].Value)
{
// Cancel deactivation (Keep 1.0)
if (SliderValue[index].Value < 1.0)
{
SliderValue[index].Value = 1.0;
}
return;
}
if (newValue < Epsilon)
{
// Do nothing
return;
}
// Change active slider
for (var i = 0; i < SliderValue.Length; i++)
{
IsSliderActive[i].Value = (i == index);
}
for (var i = 0; i < SliderValue.Length; i++)
{
SliderValue[i].Value = IsSliderActive[i].Value ? 1.0 : 0.0;
}
await ConnectedDevice.SwitchCut(index);
}
public void BindDeviceProxy(IIdentity identity, IDeviceProxy deviceProxy)
{
ConnectedDevice device = this.GetOrCreateConnectedDevice(Preconditions.CheckNotNull(identity, nameof(identity)));
device.UpdateDeviceProxy(Preconditions.CheckNotNull(deviceProxy, nameof(deviceProxy)));
Events.BindDeviceProxy(identity);
}
public IActionResult CreateConnectedDevice([FromBody] ConnectedDeviceCreateModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model == null)
{
return(BadRequest(ModelState));
}
ClaimsIdentity claimIdentity = HttpContext.User.Identity as ClaimsIdentity;
string userId = claimIdentity.FindFirst(ClaimTypes.Name)?.Value;
if (userId == null)
{
return(BadRequest(ModelState));
}
ConnectedDevice connectedDevice = new ConnectedDevice
{
UserId = userId,
ConnectedDeviceTypeId = model.ConnectedDeviceTypeId,
Location = model.Location,
Name = model.Name,
DeviceUsedGPIOs = model.DeviceUsedGPIOs
};
connectedDeviceRepository.CreateConnectedDevice(connectedDevice);
return(Ok("Create Success"));
}
private async void ReadSpeed()
{
if (ConnectedDevice == null || ConnectedDevice.ConnectionState == BACConnectionState.DISCONNECTED)
{
Model.Speed = 0;
return;
}
while (ConnectedDevice != null && ConnectedDevice.ConnectionState == BACConnectionState.CONNECTED)
{
try
{
var speed = Math.Round(await ConnectedDevice.Read(260) / (float)256 / 1.609344, 0);
Model.Speed = speed;
if (speed > App.LifetimeSpeed)
{
Stats.LifetimeSpeed = speed;
App.LifetimeSpeed = speed;
}
if (speed > Stats.SessionSpeed)
{
Stats.SessionSpeed = speed;
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
UnsubscribeToDevice();
HandleConnectionState();
}
}
}
private async void ReadVoltage()
{
if (ConnectedDevice == null || ConnectedDevice.ConnectionState == BACConnectionState.DISCONNECTED)
{
Model.Voltage = 0.0;
VoltageLabel.LabelText = "0.0";
VoltageLabel.LabelColor = Color.DimGray;
return;
}
while (ConnectedDevice != null && ConnectedDevice.ConnectionState == BACConnectionState.CONNECTED)
{
try
{
Model.Voltage = await ConnectedDevice.Read(265) / (double)32;
VoltageLabel.LabelText = Model.Voltage.ToString("F0");
VoltageLabel.LabelColor = Color.Black;
}
catch (Exception exception)
{
Console.WriteLine(exception);
UnsubscribeToDevice();
}
}
}
/// <summary>
/// Run the test on the specified device.
/// </summary>
/// <param name="device">The device.</param>
private void RunTestOnDevice(ConnectedDevice device)
{
switch (device.Platform)
{
case TestPlatform.WindowsDx:
case TestPlatform.WindowsOgl:
case TestPlatform.WindowsOgles:
RunWindowsTest(device.Serial, device.Platform);
break;
case TestPlatform.Android:
if (onBamboo)
{
RunAndroidTestOnBamboo(device.Serial);
}
else
{
RunAndroidTest(device.Serial);
}
break;
case TestPlatform.Ios:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public async void SubscribeAndHandleDeviceAsync(IBacGenericDevice device)
{
//check if we chose the same device
if (ConnectedDevice == device)
{
return;
}
if (ConnectedDevice != null)
{
//unsubsribe from connection events. Devices could potentially persist.
ConnectedDevice.ConnectionStateChanged -= Device_ConnectionStateChanged;
//Disconnect if choosing new device.
if (ConnectedDevice.ConnectionState != BACConnectionState.DISCONNECTED)
{
await ConnectedDevice.Disconnect();
}
}
ConnectedDevice = device;
if (ConnectedDevice != null)
{
ConnectedDevice.ConnectionStateChanged += Device_ConnectionStateChanged;
Application.Current.Properties["device"] = ConnectedDevice.Guid;
}
// HandleConnectionState();
}
public override async Task InitializeAsync()
{
if (Disposed)
{
throw new Exception(DeviceDisposedErrorMessage);
}
await GetDeviceAsync(DeviceId);
if (ConnectedDevice != null)
{
var usbInterface = ConnectedDevice.Configuration.UsbInterfaces.FirstOrDefault();
if (usbInterface == null)
{
ConnectedDevice.Dispose();
throw new Exception("There was no Usb Interface found for the device.");
}
var interruptPipe = usbInterface.InterruptInPipes.FirstOrDefault();
if (interruptPipe == null)
{
throw new Exception("There was no interrupt pipe found on the interface");
}
interruptPipe.DataReceived += InterruptPipe_DataReceived;
//TODO: Fill in the DeviceDefinition...
// TODO: It should be possible to select a different configurations, interface, and pipes
_DefaultConfigurationInterface = ConnectedDevice.Configuration.UsbInterfaces.FirstOrDefault();
//TODO: Clean up this messaging and move down to a base class across platforms
if (_DefaultConfigurationInterface == null)
{
throw new Exception("Could not get the default interface configuration for the USB device");
}
_DefaultOutPipe = _DefaultConfigurationInterface.InterruptOutPipes.FirstOrDefault();
if (_DefaultOutPipe == null)
{
throw new Exception("Could not get the default out pipe for the default USB interface");
}
_DefaultInPipe = _DefaultConfigurationInterface.InterruptInPipes.FirstOrDefault();
if (_DefaultOutPipe == null)
{
throw new Exception("Could not get the default in pipe for the default USB interface");
}
}
else
{
throw new Exception($"Could not connect to device with Device Id {DeviceId}. Check that the package manifest has been configured to allow this device.");
}
}
private void bindContactQuality()
{
var connectedDevice = new ConnectedDevice();
Container.BindInstance(contactQualityController);
Container.BindInstance(connectedDevice);
bindContactQualityNodes();
}
public ActionResult DeleteConfirmed(int id)
{
ConnectedDevice connectedDevice = db.ConnectedDevices.Find(id);
db.ConnectedDevices.Remove(connectedDevice);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Start an auto-connection sequence
/// </summary>
private async void StartAutoConnectionRoutine()
{
Console.WriteLine("Started auto connect !!");
if (ConnectedDevice != null)
{
await ConnectedDevice.Disconnect();
ConnectedDevice = null;
}
while (ConnectedDevice == null && List.Count > 0)
{
ConnectedDevice = await BacCommunication.CurrentRepository.StartBluetoothLeAutoConnection(List);
if (ConnectedDevice != null)
{
var wheelDiameter = await ConnectedDevice.Read(227);
if (Math.Abs(wheelDiameter - 279.4) > 0.1)
{
try
{
await ConnectedDevice.Write(227, (short)279.4);
}
catch (Exception exception)
{
Console.WriteLine(exception);
UnsubscribeToDevice();
HandleConnectionState();
}
}
var gearRatio = await ConnectedDevice.Read(226) / 256;
if (gearRatio != 1)
{
try
{
await ConnectedDevice.Write(226, 1);
}
catch (Exception exception)
{
Console.WriteLine(exception);
UnsubscribeToDevice();
HandleConnectionState();
}
}
}
}
if (ConnectedDevice == null)
{
return;
}
App.LocalDevice = ConnectedDevice;
HandleConnectionState();
SubscribeToConnectedDevice();
}
public void SetDependencies(ConnectedDevice device, HeadsetGroup headsetGroup,
ConnectionIndicatorGroup connectionIndicatorGroup,
DataSubscriber subscriber)
{
this.connectedDevice = device;
this.headsetGroup = headsetGroup;
this.connectionIndicatorGroup = connectionIndicatorGroup;
dataSubscriber = subscriber;
}
public List <Channel> GetAllOutputChannels(ConnectedDevice device)
{
if (device == null)
{
return(null);
}
var outputTypes = new[] { "do", "ao" };
return(device.Channels.Where(channel => outputTypes.Any(type => channel.Type.Equals(type))).ToList());
}
public List <Channel> GetAllInputChannels(ConnectedDevice device)
{
if (device == null)
{
return(null);
}
var inputTypes = new[] { "ai", "relay", "di" };
return(device.Channels.Where(channel => inputTypes.Any(type => channel.Type.Equals(type))).ToList());
}
public ActionResult Edit([Bind(Include = "ConnectedDeviceID,Mac")] ConnectedDevice connectedDevice)
{
if (ModelState.IsValid)
{
db.Entry(connectedDevice).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(connectedDevice));
}
public void UpdateConnectedDevice(string connectedDeviceId, ConnectedDevice updateConnectedDevice)
{
FilterDefinition <ConnectedDevice> filter = Builders <ConnectedDevice> .Filter.Eq(connectedDevice => connectedDevice.Id, connectedDeviceId);
UpdateDefinition <ConnectedDevice> update = Builders <ConnectedDevice> .Update
.Set(connectedDevice => connectedDevice.Name, updateConnectedDevice.Name)
.Set(connectedDevice => connectedDevice.Location, updateConnectedDevice.Location);
connectedDevices.FindOneAndUpdate(filter, update);
}
// checks to see if a connected device exists in database and adds it if not
public void autoCreateConnectedDevice(string macAddress)
{
if (!db.ConnectedDevices.Any(x => x.Mac == macAddress))
{
ConnectedDevice newConnDev = new ConnectedDevice();
newConnDev.Mac = macAddress;
db.ConnectedDevices.Add(newConnDev);
db.SaveChanges();
}
}
public ActionResult Create([Bind(Include = "ConnectedDeviceID,Mac")] ConnectedDevice connectedDevice)
{
if (ModelState.IsValid)
{
db.ConnectedDevices.Add(connectedDevice);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(connectedDevice));
}
public void PowerUpdateResistanceChange()
{
FlushResistanceAndUp(this.gameObject);
if (connectedDevices.Count > 0)
{
foreach (IElectricityIO ConnectedDevice in connectedDevices)
{
ConnectedDevice.ResistanceInput(ElectricalSynchronisation.currentTick, 1.11111111f, this.gameObject, null);
}
ElectricityFunctions.CircuitResistanceLoop(this, this);
}
}
public async Task <Try <ICloudProxy> > CreateCloudConnectionAsync(IClientCredentials credentials)
{
Preconditions.CheckNotNull(credentials, nameof(credentials));
ConnectedDevice device = this.CreateOrUpdateConnectedDevice(credentials.Identity);
Try <ICloudConnection> newCloudConnection = await device.CreateOrUpdateCloudConnection(c => this.CreateOrUpdateCloudConnection(c, credentials));
Events.NewCloudConnection(credentials.Identity, newCloudConnection);
Try <ICloudProxy> cloudProxyTry = GetCloudProxyFromCloudConnection(newCloudConnection, credentials.Identity);
return(cloudProxyTry);
}
async Task <byte[]> IConfigService.ReadConfig(string property)
{
var ConfigService = await ConnectedDevice.GetServiceAsync(ConfigServiceGuid);
var KeyCharacteristic = await ConfigService.GetCharacteristicAsync(KeyCharacteristicGuid);
var ValueCharacteristic = await ConfigService.GetCharacteristicAsync(ValueCharacteristicGuid);
await KeyCharacteristic.WriteAsync(Encoding.UTF8.GetBytes(property));
return(await ValueCharacteristic.ReadAsync());
}
public async Task <uint> WriteReportAsync(byte[] data, byte reportId, CancellationToken cancellationToken = default)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (DataReceiver.HasData)
{
Logger.LogWarning("Writing to device but data has already been received that has not been read");
}
var tranformedData = _writeTransferTransform(data, reportId);
var buffer = tranformedData.AsBuffer();
//We pass the report id. All this does is sets the array at index zero to the report id
//This gets overwritten by the tranform anyway
//It would probably be nice to set the values in outReport.Data from index 1-Length but it doesn't seem possible to do that
var outReport = ConnectedDevice.CreateOutputReport(reportId);
outReport.Data = buffer;
try
{
var operation = ConnectedDevice.SendOutputReportAsync(outReport);
var count = await operation.AsTask(cancellationToken);
if (count == tranformedData.Length)
{
//Get the actual data sent, and the actual number of bytes written and log them
var transferResult = new TransferResult(outReport.Data.ToArray(), count);
Logger.LogDataTransfer(new Trace(true, transferResult));
}
else
{
Logger.LogError(Messages.GetErrorMessageInvalidWriteLength(tranformedData.Length, count) + "{length} {count}", tranformedData.Length, count, GetType().Name);
throw new IOException(Messages.GetErrorMessageInvalidWriteLength(tranformedData.Length, count));
}
return(count);
}
catch (ArgumentException ex)
{
//TODO: Check the string is nasty. Validation on the size of the array being sent should be done earlier anyway
if (string.Equals(ex.Message, "Value does not fall within the expected range.", StringComparison.Ordinal))
{
throw new IOException("It seems that the data being sent to the device does not match the accepted size. Try specifying a write transfer transform", ex);
}
throw;
}
}
async Task <Try <ICloudProxy> > TryGetCloudConnection(string id)
{
IIdentity identity = this.identityProvider.Create(Preconditions.CheckNonWhiteSpace(id, nameof(id)));
ConnectedDevice device = this.GetOrCreateConnectedDevice(identity);
Try <ICloudConnection> cloudConnectionTry = await device.GetOrCreateCloudConnection(
c => this.ConnectToCloud(c.Identity, this.CloudConnectionStatusChangedHandler));
Events.GetCloudConnection(device.Identity, cloudConnectionTry);
Try <ICloudProxy> cloudProxyTry = GetCloudProxyFromCloudConnection(cloudConnectionTry, device.Identity);
return(cloudProxyTry);
}
public void InjectDependencies(UI_ConnectingToCortex connectingToCortex, HeadsetGroup headsetGroup,
ConnectHeadsetAdapter adapter, ConnectedDevice connectedDevice,
ContactQualityController contactQualityController,
ConnectionIndicatorGroup connectionIndicatorGroup)
{
_headsetAdapter = adapter;
_connectedDevice = connectedDevice;
_contactQualityController = contactQualityController;
_connectingToCortex = connectingToCortex;
_connectionIndicatorGroup = connectionIndicatorGroup;
init();
}
private async Task ToOutputMode()
{
if (_viewMode.Value == ViewMode.Output)
{
return;
}
_viewMode.OnNext(ViewMode.Output);
if (ConnectedDevice.IsConnected)
{
await ConnectedDevice.PreviewProgramOut();
}
}
private async Task ToInputMode()
{
if (_viewMode.Value == ViewMode.Input)
{
return;
}
_viewMode.OnNext(ViewMode.Input);
if (ConnectedDevice.IsConnected)
{
await ConnectedDevice.PreviewInputTile();
}
}
public async Task AddDeviceConnection(IIdentity identity, IDeviceProxy deviceProxy)
{
ConnectedDevice device = this.GetOrCreateConnectedDevice(Preconditions.CheckNotNull(identity, nameof(identity)));
Option <IDeviceProxy> currentDeviceProxy = device.UpdateDeviceProxy(Preconditions.CheckNotNull(deviceProxy, nameof(deviceProxy)));
Events.NewDeviceConnection(identity);
await currentDeviceProxy
.Filter(dp => dp.IsActive)
.ForEachAsync(dp => dp.CloseAsync(new MultipleConnectionsException($"Multiple connections detected for device {identity.Id}")));
this.DeviceConnected?.Invoke(this, identity);
}
// GET: ConnectedDevices/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ConnectedDevice connectedDevice = db.ConnectedDevices.Find(id);
if (connectedDevice == null)
{
return(HttpNotFound());
}
return(View(connectedDevice));
}
async Task RemoveDeviceConnection(ConnectedDevice device, bool removeCloudConnection)
{
await device.DeviceConnection.Filter(dp => dp.IsActive)
.ForEachAsync(dp => dp.CloseAsync(new EdgeHubConnectionException($"Connection closed for device {device.Identity.Id}.")));
if (removeCloudConnection)
{
await device.CloudConnection.Filter(cp => cp.IsActive)
.ForEachAsync(cp => cp.CloseAsync());
}
Events.RemoveDeviceConnection(device.Identity.Id);
this.DeviceDisconnected?.Invoke(this, device.Identity);
}
public async Task WriteReportAsync(byte[] data, byte?reportId)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
byte[] bytes;
if (DataHasExtraByte)
{
bytes = new byte[data.Length + 1];
Array.Copy(data, 0, bytes, 1, data.Length);
bytes[0] = reportId ?? DefaultReportId;
}
else
{
bytes = data;
}
var buffer = bytes.AsBuffer();
var outReport = ConnectedDevice.CreateOutputReport();
outReport.Data = buffer;
try
{
var operation = ConnectedDevice.SendOutputReportAsync(outReport);
var count = await operation.AsTask();
if (count == bytes.Length)
{
Tracer?.Trace(true, bytes);
}
else
{
var message = Messages.GetErrorMessageInvalidWriteLength(bytes.Length, count);
Logger?.Log(message, GetType().Name, null, LogLevel.Error);
throw new IOException(message);
}
}
catch (ArgumentException ex)
{
//TODO: Check the string is nasty. Validation on the size of the array being sent should be done earlier anyway
if (string.Equals(ex.Message, "Value does not fall within the expected range.", StringComparison.Ordinal))
{
throw new IOException("It seems that the data being sent to the device does not match the accepted size. Have you checked DataHasExtraByte?", ex);
}
throw;
}
}
/// <summary>
/// Run the test on the specified device.
/// </summary>
/// <param name="device">The device.</param>
private void RunTestOnDevice(ConnectedDevice device)
{
switch (device.Platform)
{
case TestPlatform.WindowsDx:
case TestPlatform.WindowsOgl:
case TestPlatform.WindowsOgles:
RunWindowsTest(device.Serial, device.Platform);
break;
case TestPlatform.Android:
if (onBamboo)
RunAndroidTestOnBamboo(device.Serial);
else
RunAndroidTest(device.Serial);
break;
case TestPlatform.Ios:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Run the test.
/// </summary>
/// <param name="device">The device where to run the test.</param>
/// <param name="gameContext">The game context.</param>
public void RunTest(ConnectedDevice device, GameContext gameContext = null)
{
currentDevice = device;
runTests = true;
Console.WriteLine(@"Running test " + this.GetType().Name + @" on device " + device.Name + @" (" + device.Platform + @")");
// TODO: should be executed after LoadContent for client - or at the first frame?
RegisterTests();
if (isServer)
{
Console.WriteLine(@"Running server" + (onBamboo ? @" on Bamboo" : @"" ));
// Launch server
SetUpServer();
if (!serverUp)
{
Assert.Fail("Unable to create a server.");
return;
}
// Reset some variables
imageReceived = false;
testPerformed = false;
dataReceivedEvent = new ManualResetEvent(false);
// Launch remote test
Console.WriteLine(@"Waiting for a connection... ");
//server.BeginAcceptTcpClient(GetClientResultCallback, server);
RunTestOnDevice(device);
// Wait until data is received or timeout
dataReceivedEvent.WaitOne(Timeout);
try
{
Console.WriteLine(@"Stopping the server.");
serverUp = false;
StopServer();
}
catch (Exception)
{
Console.WriteLine(@"Stopping the server threw an error.");
}
finally
{
// Some tests
Assert.IsTrue(imageReceived, "The image was not received.");
Assert.IsTrue(testPerformed, "The tests were not correctly performed");
}
}
else
{
Console.WriteLine(@"Running test client");
// 1. Create client
SetUpClient();
// 2. Run game
Run(gameContext);
}
}
public int RunAndroidTest(ConnectedDevice device, bool reinstall, string packageName, string packageFile, string resultFile)
{
try
{
server = StartServer();
if (reinstall)
{
// force stop - only works for Android 3.0 and above.
var o0 = ShellHelper.RunProcessAndGetOutput(@"adb", string.Format(@"-s {0} shell am force-stop {1}", device.Serial, packageName));
// uninstall
ShellHelper.RunProcessAndGetOutput(@"adb", string.Format(@"-s {0} uninstall {1}", device.Serial, packageName));
// install
var o1 = ShellHelper.RunProcessAndGetOutput(@"adb", string.Format(@"-s {0} install {1}", device.Serial, packageFile));
Console.WriteLine("adb install: exitcode {0}\nOutput: {1}\nErrors: {2}", o1.ExitCode, string.Join(Environment.NewLine, o1.OutputLines), string.Join(Environment.NewLine, o1.OutputErrors));
if (o1.ExitCode != 0)
throw new InvalidOperationException("Invalid error code from adb install");
}
// run
var parameters = new StringBuilder();
parameters.Append("-s "); parameters.Append(device.Serial);
parameters.Append(@" shell am start -a android.intent.action.MAIN -n " + packageName + "/nunitlite.tests.MainActivity");
AddAndroidParameter(parameters, TestRunner.ParadoxServerIp, serverAddresses);
AddAndroidParameter(parameters, TestRunner.ParadoxServerPort, ((IPEndPoint)server.Server.LocalEndPoint).Port.ToString());
AddAndroidParameter(parameters, TestRunner.ParadoxBuildNumber, buildNumber.ToString());
if (!String.IsNullOrEmpty(branchName))
AddAndroidParameter(parameters, TestRunner.ParadoxBranchName, branchName);
Console.WriteLine(parameters.ToString());
var o2 = ShellHelper.RunProcessAndGetOutput(@"adb", parameters.ToString());
Console.WriteLine("adb shell am start: exitcode {0}\nOutput: {1}\nErrors: {2}", o2.ExitCode, string.Join(Environment.NewLine, o2.OutputLines), string.Join(Environment.NewLine, o2.OutputErrors));
if (o2.ExitCode != 0)
throw new InvalidOperationException("Invalid error code from adb shell am start");
// Wait for client to connect
var client = server.AcceptTcpClient();
Console.WriteLine("Device connected, wait for results...");
var clientStream = client.GetStream();
var binaryReader = new BinaryReader(clientStream);
// Read output
var output = binaryReader.ReadString();
Console.WriteLine(output);
// Read XML result
var result = binaryReader.ReadString();
Console.WriteLine(result);
// Write XML result to disk
File.WriteAllText(resultFile, result);
return 0;
}
catch (Exception e)
{
Console.WriteLine(@"An error was thrown when running the test on Android: {0}", e);
return -1;
}
}
public int RunAndroidTest(ConnectedDevice device, bool reinstall, string packageName, string packageFile, string resultFile)
{
try
{
server = StartServer();
ProcessOutputs adbOutputs;
var adbPath = AndroidDeviceEnumerator.GetAdbPath();
if (adbPath == null)
throw new InvalidOperationException("Can't find adb");
var logStack = new List<string>();
if (reinstall)
{
// force stop - only works for Android 3.0 and above.
adbOutputs = ShellHelper.RunProcessAndGetOutput(adbPath, string.Format(@"-s {0} shell am force-stop {1}", device.Serial, packageName));
// uninstall
adbOutputs = ShellHelper.RunProcessAndGetOutput(adbPath, string.Format(@"-s {0} uninstall {1}", device.Serial, packageName));
// install
adbOutputs = ShellHelper.RunProcessAndGetOutput(adbPath, string.Format(@"-s {0} install {1}", device.Serial, packageFile));
Console.WriteLine("adb install: exitcode {0}\nOutput: {1}\nErrors: {2}", adbOutputs.ExitCode, adbOutputs.OutputAsString, adbOutputs.ErrorsAsString);
if (adbOutputs.ExitCode != 0)
throw new InvalidOperationException("Invalid error code from adb install.\n Shell log: {0}");
}
// run
var parameters = new StringBuilder();
parameters.Append("-s "); parameters.Append(device.Serial);
parameters.Append(@" shell am start -a android.intent.action.MAIN -n " + packageName + "/nunitlite.tests.MainActivity");
AddAndroidParameter(parameters, TestRunner.XenkoServerIp, serverAddresses);
AddAndroidParameter(parameters, TestRunner.XenkoServerPort, ((IPEndPoint)server.Server.LocalEndPoint).Port.ToString());
AddAndroidParameter(parameters, TestRunner.XenkoBuildNumber, buildNumber.ToString());
if (!String.IsNullOrEmpty(branchName))
AddAndroidParameter(parameters, TestRunner.XenkoBranchName, branchName);
Console.WriteLine(parameters.ToString());
adbOutputs = ShellHelper.RunProcessAndGetOutput(adbPath, parameters.ToString());
Console.WriteLine("adb shell am start: exitcode {0}\nOutput: {1}\nErrors: {2}", adbOutputs.ExitCode, adbOutputs.OutputAsString, adbOutputs.ErrorsAsString);
if (adbOutputs.ExitCode != 0)
throw new InvalidOperationException("Invalid error code from adb shell am start.");
// Wait for client to connect
const int WaitingTime = 30;
for (int i = 0; i < WaitingTime; i++)
{
if (server.Pending())
break;
Thread.Sleep(1000);
}
if (!server.Pending())
throw new InvalidOperationException("The client (the remote test application) failed to establish the connection.");
var client = server.AcceptTcpClient();
Console.WriteLine("Device connected, wait for results...");
var clientStream = client.GetStream();
var binaryReader = new BinaryReader(clientStream);
// Read output
var output = binaryReader.ReadString();
Console.WriteLine(output);
// Read XML result
var result = binaryReader.ReadString();
Console.WriteLine(result);
// Write XML result to disk
File.WriteAllText(resultFile, result);
return 0;
}
catch (Exception e)
{
Console.WriteLine(@"An error was thrown when running the test on Android: {0}", e);
return -1;
}
}
