public async void GetById_ShouldReturnsStatusCodeOk_And_ResponseBodyIsNotNull_And_DtoIdEqualsRequestId_WhenPassValidId(string value)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync((string id) => new HardwareDto {
Id = id
});
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.GetById(value);
Assert.NotNull(response);
var expectedType = typeof(OkObjectResult);
Assert.IsType(expectedType, response);
var responseOk = response as OkObjectResult;
Assert.NotNull(responseOk.Value);
var dto = responseOk.Value as HardwareDto;
Assert.Equal(value, dto.Id);
}
public async void Add_ShouldReturnsBadRequest_WhenPassInvalidNameToDto(string name)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.AddAsync(It.IsAny <HardwareDto>()))
.Callback((HardwareDto dto) =>
{
dto.Name = name;
dto.Id = Guid.NewGuid().ToString();
Console.WriteLine($"{dto.Id}");
})
.ReturnsAsync((HardwareDto dto) => dto);
var service = mockService.Object;
var controller = new HardwareController(service);
controller.ModelState.AddModelError("Name", "Required");
var response = await controller.Create(new HardwareDto { Name = name });
Assert.NotNull(response);
var expectedType = typeof(BadRequestObjectResult);
Assert.IsType(expectedType, response);
}
public void SetAxisAndInitGUI(HardwareController hwc, Axis axis)
{
HWC = hwc;
MyAxis = axis;
Data.AxisName = MyAxis.ControlIdent;
EnableChange(axis, axis.IsEnable);
HasFaultChange(axis, axis.HasFault);
this.Data.AbsPosStr = Axis.SConvertIntToStr(MyAxis.Position, true);
this.Data.RelPosStr = Axis.SConvertIntToStr(HWC.ConvertCoordinatesAlways(MyAxis.ControlIdent, -MyAxis.Position) * (-1), true);
//Verbinde Notifyer
MyAxis.IsEnableChanged += EnableChange;
MyAxis.HasFaultChange += HasFaultChange;
MyAxis.PositionChange += PositionChange;
MyAxis.VelocityChange += VelocityChange;
//Load Values
DataSafe ds = new DataSafe(Paths.SettingsPath, "MainWindow");
Speed = ds.Ints[axis.ControlIdent + "-FR-Speed", 0];
Distance = ds.Ints[axis.ControlIdent + "-FR-Distance", 0];
UseDistance = ds.Bools[axis.ControlIdent + "-FR-UseDis", false];
DisplayFreeRunValues();
FreeRunThread = new TrackedThread("Free Run Distance Thread: " + MyAxis, this.FreeRunThreadMethod);
FreeRunQueue = new Queue <Action>();
FreeRunThread.Start();
}
public async void LoadByFloor_ShouldReturnsResponseBodyWithTwoElementInList_And_ElementsIsImmobilized_And_ImmobilizerFloorContainsLevelEqualFloorLevelParameter_WhenPassFloorLevelValid_And_ServiceReturnFullList(int floorLevel)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.LoadByFloorAsync(It.IsAny <FloorDto>()))
.ReturnsAsync((FloorDto floor) =>
{
floor.LevelName = "Infra";
return(new List <HardwareDto>
{
new HardwareDto {
Id = Guid.NewGuid().ToString(), Name = "Computador", ImmobilizerFloor = floor
},
new HardwareDto {
Id = Guid.NewGuid().ToString(), Name = "Computador", ImmobilizerFloor = floor
}
});
});
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.LoadByFloor(floorLevel);
Assert.NotNull(response);
Assert.NotEmpty(response);
Assert.Equal(2, response.Count);
Assert.All(response, (element) =>
{
Assert.True(element.IsImmobilized);
Assert.True(element.ImmobilizerFloor?.Level == floorLevel);
});
}
public void SetHWC(HardwareController hwc)
{
HWC = hwc;
string[] idents = hwc.IOControllerControlIdents;
Array.Sort <string>(idents);
ParameterControllerColumn.ItemsSource = new List <string>(idents);
IOPortType[] s = new IOPortType[] { IOPortType.NOUSE, IOPortType.IN, IOPortType.INOUT, IOPortType.OUT };
ParameterPortTypeColumn.ItemsSource = new List <IOPortType>(s);
List <IOGridEntry> entrys = new List <IOGridEntry>();
foreach (var i in idents)
{
IOController ic = hwc.GetIOController(i);
IOPort[] all = ic.All;
foreach (var p in all)
{
entrys.Add(new IOGridEntry()
{
ParamController = i,
ParamBit = p.Bit,
ParamPortType = p.PortType,
ParamInName = p.InName,
ParamOutName = p.OutName
});
}
}
Data.Parameters = entrys;
}
public async void Update_ShouldReturnsBadRequest_WhenPassValidId_And_ServiceNotFoundHardware(string idParameter)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync((HardwareDto)null);
mockService.Setup(s => s.UpdateAsync(It.IsAny <string>(), It.IsAny <HardwareDto>()))
.Returns(Task.FromResult(0));
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.Update(idParameter,
new HardwareDto
{
Id = idParameter,
Name = "Computador"
}
);
Assert.NotNull(response);
var expectedType = typeof(NotFoundObjectResult);
Assert.IsType(expectedType, response);
}
public async void Update_ShouldReturnsNoContents_And_ReturnsResponseBodyNotNull_AndValidDtoEqualIdDtoIdParameter_WhenPassValidId_And_PassValidToDto(string idParameter)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync((string id) =>
new HardwareDto
{
Id = idParameter,
Name = "Computador",
FacoryCode = Guid.NewGuid().ToString()
});
mockService.Setup(s => s.UpdateAsync(It.IsAny <string>(), It.IsAny <HardwareDto>()))
.Returns(Task.FromResult(0));
var service = mockService.Object;
var controller = new HardwareController(service);
var updatingDto = new HardwareDto
{
Id = idParameter,
Name = "Computador",
FacoryCode = Guid.NewGuid().ToString()
};
var response = await controller.Update(idParameter, updatingDto);
Assert.NotNull(response);
var expectedType = typeof(NoContentResult);
Assert.IsType(expectedType, response);
}
public async void Update_ShouldReturnsBadRequest_WhenPassIdParameterIsDiferenteDtoId(string idParameter)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync(new HardwareDto());
mockService.Setup(s => s.UpdateAsync(It.IsAny <string>(), It.IsAny <HardwareDto>()))
.Returns(Task.FromResult(0));
var service = mockService.Object;
var controller = new HardwareController(service);
controller.ModelState.AddModelError("Id", "Required");
controller.ModelState.AddModelError("Name", "Required");
var response = await controller.Update(idParameter,
new HardwareDto
{
Id = Guid.NewGuid().ToString(),
Name = "Computador"
}
);
Assert.NotNull(response);
var expectedType = typeof(BadRequestObjectResult);
Assert.IsType(expectedType, response);
}
public async void Add_ShouldReturnsCreatedAtRouteResult_WhenPassValidDto()
{
var mockService = new Mock <IHardwareService>();
var addHardware = new HardwareDto
{
Name = "Computador",
Brand = "HP",
Description = "2gb de ram",
FacoryCode = "123123"
};
mockService.Setup(s => s.AddAsync(It.IsAny <HardwareDto>()))
.Callback((HardwareDto dto) =>
{
dto.Id = Guid.NewGuid().ToString();
})
.ReturnsAsync((HardwareDto dto) => dto);
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.Create(addHardware);
Assert.NotNull(response);
var expectedType = typeof(CreatedResult);
Assert.IsType(expectedType, response);
}
private void StartLoading(Stopwatch timer)
{
UpdateProgress("Reading Config File");
AlexaComp.ReadConfig();
UpdateProgress("Creating Port Map", 400);
AlexaCompSERVER.ForwardPort();
UpdateProgress("Scanning for RGB Devices");
AlexaComp.LightingControlThread.Start();
UpdateProgress("Assigning Sensors");
HardwareController.InitSensors();
UpdateProgress("Getting Installed Programs");
ProgramInventory.ScanDir();
UpdateProgress("Starting Server");
AlexaCompCore.ServerThread.Start();
UpdateProgress("Starting Server Loop");
AlexaCompCore.ServerLoopThread.Start();
UpdateProgress("Starting AlexaComp", 400);
CloseSplashScreen();
AlexaComp.AppWindowThread.Start();
timer.Stop();
AlexaCompCore.Clog(String.Format("Application Window started in {0} ms.", timer.ElapsedMilliseconds));
}
public void PutHardware_ShouldFail_WhenDifferentID()
{
var controller = new HardwareController(new TestHardwareAppContext());
var badresult = controller.PutHardware(999, GetDemoHardware());
Assert.IsInstanceOfType(badresult, typeof(BadRequestResult));
}
public async void LoadByIsImmobilized_ShouldReturnsResponseBodyWithTwoElementInList_WhenPassIsImmobilizedTrueOrFalse_And_ServiceReturnFullList(bool isImmobilized)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.LoadByIsImmobilizedAsync(It.Is <bool>(c => c)))
.ReturnsAsync((bool value) =>
{
return(new List <HardwareDto>
{
new HardwareDto
{
Id = Guid.NewGuid().ToString(),
Name = "Computador Lenovo",
ImmobilizerFloor = new FloorDto
{
Level = 1,
LevelName = "T.I"
}
},
new HardwareDto
{
Id = Guid.NewGuid().ToString(),
Name = "Computador HP",
ImmobilizerFloor = new FloorDto
{
Level = 1,
LevelName = "T.I"
}
}
});
});
mockService.Setup(s => s.LoadByIsImmobilizedAsync(It.Is <bool>(c => !c)))
.ReturnsAsync((bool value) =>
{
return(new List <HardwareDto>
{
new HardwareDto
{
Id = Guid.NewGuid().ToString(),
Name = "Mouse Apple"
},
new HardwareDto
{
Id = Guid.NewGuid().ToString(),
Name = "Mouse Dell"
}
});
});
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.LoadByIsImmobilized(isImmobilized);
Assert.NotNull(response);
Assert.NotEmpty(response);
Assert.Equal(2, response.Count);
Assert.All(response, (element) => Assert.Equal(isImmobilized, element.IsImmobilized));
}
public void SetHWC(HardwareController hwc)
{
HWC = hwc;
string[] all = HWC.AxesControlIdents;
foreach (string s in all)
{
Data.AllAxesItems.Add(s);
}
}
public void SetHWC(HardwareController hwc)
{
HWC = hwc;
string[] all = HWC.ToolsControlIdents;
Array.Sort <string>(all);
foreach (string s in all)
{
Data.AllToolsItems.Add(s);
}
}
public void GetHardware_ShouldReturnHardwareWithSameID()
{
var context = new TestHardwareAppContext();
context.Hardwares.Add(GetDemoHardware());
var controller = new HardwareController(context);
var result = controller.GetHardware(3) as OkNegotiatedContentResult <Hardware>;
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Content.Id);
}
public async void LoadByIsImmobilized_ShouldReturnsResponseBodyWithNullList_WhenPassIsImmobilizedTrueOrFalse_And_ServiceReturnNullList(bool isImmobilized)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.LoadByIsImmobilizedAsync(It.IsAny <bool>()))
.ReturnsAsync((List <HardwareDto>)null);
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.LoadByIsImmobilized(isImmobilized);
Assert.Null(response);
}
public async void LoadByFloor_ShouldReturnsResponseBodyWithNullList_WhenPassInvalidFloorLevel_And_ServiceReturnNullList(int floorLevel)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.LoadByFloorAsync(It.IsAny <FloorDto>()))
.ReturnsAsync((List <HardwareDto>)null);
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.LoadByFloor(floorLevel);
Assert.Null(response);
}
public async void LoadAll_ShouldReturnsNullList_WhenServiceReturnNullList()
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.LoadAllAsync())
.ReturnsAsync((List <HardwareDto>)null);
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.LoadAll();
Assert.Null(response);
}
public void PutHardware_ShouldReturnStatusCode()
{
var controller = new HardwareController(new TestHardwareAppContext());
var item = GetDemoHardware();
var result = controller.PutHardware(item.Id, item) as StatusCodeResult;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
Assert.AreEqual(HttpStatusCode.NoContent, result.StatusCode);
}
public HardwareSettings(HardwareController hwc)
{
InitializeComponent();
Data = FindResource("datahandler") as HardwareSettingsDataHandler;
HWC = hwc;
this.SetHWC();
AxesConfig.SetHWC(hwc);
IOConfig.SetHWC(hwc);
ToolsConfig.SetHWC(hwc);
}
public void DeleteHardware_ShouldReturnOK()
{
var context = new TestHardwareAppContext();
var item = GetDemoHardware();
context.Hardwares.Add(item);
var controller = new HardwareController(context);
var result = controller.DeleteHardware(3) as OkNegotiatedContentResult <Hardware>;
Assert.IsNotNull(result);
Assert.AreEqual(item.Id, result.Content.Id);
}
public static void RunTest(MainWindow mw, HardwareController hwc)
{
#if TEST
MW = mw;
HWC = hwc;
while (true)
{
TestWindow tw = new TestWindow();
if (tw.ShowDialog() != true)
{
continue;
}
int testNr = tw.SelectedTest.SelectedIndex;
switch (testNr)
{
case 0:
TrackedThread testThread = new TrackedThread("Test ImgButton", Test1);
testThread.Start();
return;
case 1:
TrackedThread testThread2 = new TrackedThread("Test Enable Move Move Home Disable", Test2);
testThread2.Start();
return;
case 2:
TrackedThread testThread3 = new TrackedThread("Test TabControl Main Window", Test3);
testThread3.Thread.SetApartmentState(ApartmentState.STA);
testThread3.Start();
return;
case 3:
TrackedThread testThread4 = new TrackedThread("Test Script with FAK", Test4);
testThread4.Thread.SetApartmentState(ApartmentState.STA);
testThread4.Start();
return;
case 4:
TrackedThread testThread5 = new TrackedThread("Test Script with FAK", Test5);
testThread5.Thread.SetApartmentState(ApartmentState.STA);
testThread5.Start();
return;
default:
MessageBox.Show("Unknown Test ");
break;
}
}
#endif
}
public SampleSeries(int numSamples,
HardwareController controller,
TextMeshProUGUI minText,
TextMeshProUGUI currText,
TextMeshProUGUI maxText)
{
_NumSamples = numSamples;
_MinSamples = new List <int>();
_MaxSamples = new List <int>();
_Controller = controller;
_MinText = minText;
_CurrText = currText;
_MaxText = maxText;
}
public async void Delete_ShouldReturnsBadRequest_WhenPassInvalidId(string id)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.UpdateAsync(It.IsAny <string>(), It.IsAny <HardwareDto>()))
.Returns(Task.FromResult(0));
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.Delete(id);
Assert.NotNull(response);
var expectedType = typeof(BadRequestObjectResult);
Assert.IsType(expectedType, response);
}
public async void GetById_ShouldReturnsBadRequest_WhenIdRequestIsInvalid(string id)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync(new HardwareDto());
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.GetById(id);
Assert.NotNull(response);
var expectedType = typeof(BadRequestObjectResult);
Assert.IsType(expectedType, response);
}
public async void GetById_ShouldReturnsRequestNotFound_WhenServiceReturnNull(string value)
{
var mockService = new Mock <IHardwareService>();
mockService.Setup(s => s.GetByIdAsync(It.IsAny <string>()))
.ReturnsAsync((HardwareDto)null);
var service = mockService.Object;
var controller = new HardwareController(service);
var response = await controller.GetById(value);
Assert.NotNull(response);
var expectedType = typeof(NotFoundObjectResult);
Assert.IsType(expectedType, response);
}
/// <summary>
/// Erstellt für alle Achsen im HardwareController die GUI Elemente.
/// </summary>
/// <param name="hwc">Der Verbundene HardwareController</param>
public void SetHardwareControllerAndInitGUI(HardwareController hwc)
{
HWC = hwc;
string[] axes = hwc.AxesControlIdents;
for (int i = 0; i < axes.Length; ++i)
{
MainGrid.RowDefinitions.Add(NewRowDef());
Axis a = HWC.GetAxis(axes[i]);
UI_OneAxis one = new UI_OneAxis();
one.SetAxisAndInitGUI(HWC, a);
Grid.SetRow(one, i + 1);
MainGrid.Children.Add(one);
}
}
public void PostHardware_ShouldReturnSameHardware()
{
var controller = new HardwareController(new TestHardwareAppContext());
var item = GetDemoHardware();
var result =
controller.PostHardware(item) as CreatedAtRouteNegotiatedContentResult <Hardware>;
Assert.IsNotNull(result);
Assert.AreEqual(result.RouteName, "DefaultApi");
Assert.AreEqual(result.RouteValues["id"], result.Content.Id);
Assert.AreEqual(result.Content.Description, item.Description);
Assert.AreEqual(result.Content.PurchasePrice, item.PurchasePrice);
Assert.AreEqual(result.Content.SerialNumber, item.SerialNumber);
Assert.AreEqual(result.Content.Type, item.Type);
}
public void StartupInit()
{
DataSafe ds = new DataSafe(Paths.SettingsPath, "MainWindow");
if (!ds.containsKey("SelectedHardware") || ds.Ints["SelectedHardware"] < 0)
{
HardwareSelector hws = new HardwareSelector(ds);
if (hws.ShowDialog() != true)
{
Environment.Exit(0);
}
}
LoadingWindow lw = new LoadingWindow(ds);
lw.Load();
this.WindowState = ds.Bools["Maximized", false] ? System.Windows.WindowState.Maximized : System.Windows.WindowState.Normal;
this.HWC = lw.HWC;
CameraClickAndMove.SetHWC(this.HWC);
//Init 1 CloseableTabItem
Data.TabItems_Add(new CloseableTabItem("new"));
// Init UI Elemente
AxesControl.SetHardwareControllerAndInitGUI(HWC);
IOControl.SetHardwareControllerAndInitGUI(HWC);
//Verbinde EventHandler
ScriptHandler.OnState1Changed += this.OnScriptHandlerStateChange_1;
ScriptHandler.OnState2Changed += this.OnScriptHandlerStateChange_2;
//Data.CodeTextFieldItems = new List<string>();
//Load last X Commands
List <string> s = new List <string>();
int x = ds.Ints["CodeTextFieldItemsCount", 0];
for (int i = 0; i < x; ++i)
{
s.Add(ds.Strings["CTFI-" + i, ""]);
}
Data.CodeTextFieldItems = s;
#if TEST
Tests.TestClass.RunTest(this, HWC);
#endif
}
// private IEnumerator logout() {
// setStatus(RESTARTING_SESSION);
// logoutLoaded = false;
//
// webView.url = ServerInteract.LOGOUT_URL;
// webView.Load();
//
// while (!logoutLoaded) {
// yield return null;
// }
//
// if (clearCache) {
// webView.CleanCache ();
// webView.CleanCookie ();
// }
//
// setStatus (SESSION_RESTARTED);
//
// yield return "Done";
// }
//
// private IEnumerator tryAutoLogin() {
// setStatus (START_AUTO_LOGIN);
// autoLoginWorked = false;
//
// SavedCredentials savedCreds = readTokenAndUsernameFromFile ();
// if (savedCreds != null) {
// setStatus(REAUTHORIZING_SAVED_TOKEN);
//
// authToken = savedCreds.savedAuthtoken;
//
// ServerCall testSavedAuth = new ServerCall(ServerInteract.INSTANCE.SendServerInformationRequest (ServerInteract.TEST_LOGIN, null));
// yield return StartCoroutine (testSavedAuth.call ());
//
//
// if(testSavedAuth.ReturnException == null) {
//
// setStatus(SAVED_TOKEN_SUCCESS);
//
// authToken = savedCreds.savedAuthtoken;
// StartCoroutine(startLoadUserData ());
// autoLoginWorked = true;
//
// } else {
// setStatus (SAVED_TOKEN_FAILED);
//
// authToken = null;
//
// if (savedCreds.savedProvider.Equals (AUTH_0_LOGIN_PROVIDER)) {
// setStatus (PROVIDER_AUTH_0);
// autoLoginWorked = false;
// } else {
// setStatus (AUTHORIZING_WITH_PROVIDER + savedCreds.savedProvider);
// loadReauthorize (savedCreds.savedProvider);
// autoLoginWorked = true;
// }
// }
// } else { // create a blank file if none is there and login has failed
//
// autoLoginWorked = false;
// }
//
// yield return "Done";
// }
// private void loadReauthorize(string provider) {
// string authorizeurl = createAuthorizeURL (provider);
//
// webView.url = authorizeurl;
// webView.Load ();
// }
// private void loadManualLogin() {
// setStatus(LOADING_MANUAL_LOGIN);
//
// webView.url = ServerInteract.MANUALLOGIN;
// webView.Load();
//
// setStatus (MANUAL_LOGIN_LOADED);
// }
// void OnLoadComplete(UniWebView webView, bool success, string errorMessage) {
// Debug.Log ("Load complete: " + webView.url);
// Debug.Log ("Load successful: " + success);
//
// if (webView.url.Equals (ServerInteract.LOGOUT_URL)) {
// logoutLoaded = true;
// } else if (webView.url.Equals (ServerInteract.MANUALLOGIN)) {
// webView.Show();
// } else if (webView.url.Contains (ServerInteract.AUTHORIZEURL)) {
// webView.Show();
// }
//
// if (!success) {
// Debug.Log("Something wrong in webview loading: " + errorMessage);
// }
//
// }
//
// void OnReceivedMessage(UniWebView webView, UniWebViewMessage message) {
//
// // You can check the message path and arguments to know which `uniwebview` link is clicked.
// // UniWebView will help you to parse your link if it follows the url argument format.
// // However, there is also a "rawMessage" property you could use if you need to use some other formats and want to parse it yourself.
// Debug.Log("Received message from: " + webView.url);
// Debug.Log ("Raw message: " + message.rawMessage);
//
// if (message.path == "success") {
// string response = message.args["authToken"].Trim();
// authToken = response;
//
// Debug.LogWarning("Auth token: " + authToken);
//
// //writeTokenToFile (authToken);
// //LoadUserData.populateUserData(authToken);
// //LoadUserData lud = new LoadUserData();
// //StartCoroutine (lud.Start());
//
// StartCoroutine(startLoadUserData ());
// }
// }
// This method will be called when the screen orientation changed. Here we return UniWebViewEdgeInsets(5,5,5,5)
// for both situation, which means the inset is 5 point for iOS and 5 pixels for Android from all edges.
// Note: UniWebView is using point instead of pixel in iOS. However, the `Screen.width` and `Screen.height` will give you a
// pixel-based value.
// You could get a point-based screen size by using the helper methods: `UniWebViewHelper.screenHeight` and `UniWebViewHelper.screenWidth` for iOS.
// UniWebViewEdgeInsets InsetsForScreenOreitation(UniWebView webView, UniWebViewOrientation orientation) {
// int INSET = 0;
// if (orientation == UniWebViewOrientation.Portrait) {
// return new UniWebViewEdgeInsets(INSET,INSET,INSET,INSET);
// } else {
// return new UniWebViewEdgeInsets(INSET,INSET,INSET,INSET);
// }
// }
private IEnumerator startLoadUserData()
{
HardwareController.initialize();
setStatus("Downloading User Profile...");
ServerCall waitFor = new ServerCall(ServerInteract.INSTANCE.GetLoggedInUserInfo());
yield return(StartCoroutine(waitFor.call()));
writeTokenAndUsernameToFile(authToken, LoggedInUser.GetLoggedInUser().GetUserId());
setStatus("Logging into Network...");
waitFor = new ServerCall(ServerInteract.INSTANCE.RetrieveFirebaseToken());
yield return(StartCoroutine(waitFor.call()));
SceneManager.LoadScene("Scenes/GroundViewScene", LoadSceneMode.Single);
}
