public void Config(RoutingRequest request)
{
foreach (string s in request.ContentTypes)
{
ContentType ct = contentTypeList.ValueSet.Find(x => x.Content.CompareTo(s) == 0);
if (ct == null)
{
var newCt = new ContentType()
{
Content = s
};
newCt.Queues = new Dictionary <string, Value>();
contentTypeList.ValueSet.Add(newCt);
ct = newCt;
logger.Debug($"Content type {ct.Content} will be created.");
}
try
{
ct.Queues.Remove("value1");
ct.Queues.Add("value1", new Value {
QueueId = "1", QueueName = request.Path
});
}
catch (Exception e)
{
logger.Debug($"{e.Message}");
}
}
}
private async Task Initialize()
{
_presenterService = ServiceProxy.Create <IPresenterService>(new Uri(_presenterServiceUri));
_exComService = ServiceProxy.Create <IExternalCommunicationService>(new Uri(_exComServiceUri));
_securityService = ServiceProxy.Create <ISecurityService>(new Uri(_securityServiceUri));
_currentKpuPackageRequests = new Dictionary <string, List <string> >();
logger.Trace($"Initializing Presenter service");
_presenterService.Initialize().Wait();
logger.Trace($"Initializing Presenter service complete");
try
{
_configuration = new ConfigurationBuilder().AddXmlFile("App.config").Build();
_amqRoutes = new Dictionary <string, string>();
_amqEndpoint = _configuration["Connection:Endpoint"];
_amqUser = _configuration["Connection:User"];
_amqPassword = _configuration["Connection:Password"];
_amqRoutes["ToBlackboard"] = _configuration["Routes:ToBlackboard"];
_amqRoutes["FromBlackboard"] = _configuration["Routes:FromBlackboard"];
await SetupActiveMq();
}
catch (Exception e)
{
logger.Error($"Exception while reading app.config and getting amq routes: {e.ToString()}");
return;
}
try
{
var proxy2 = ActorProxy.Create <IBlackboardActor>(new ActorId(42), "fabric:/Assistant");
Task <bool> ret2 = proxy2.InitBlackboard();
bool retVal3 = ret2.Result;
Task rett;
rett = proxy2.StartProcessing();
}
catch (Exception e)
{
logger.Error(e.ToString());
}
logger.Trace($"Initializing Blackboard Actor complete");
InitializeTransformerActor();
var registerForMessagesAtBlackboardRequest = new RoutingRequest()
{
Id = "Core",
Path = _amqRoutes["FromBlackboard"],
ContentTypes = new string[]
{
BrokerCommands.PACKAGE,
BrokerCommands.KPU_REGISTRATION,
BrokerCommands.MODEL_UPDATE
},
};
var registerPackage = BreanosConnectors.SerializationHelper.Pack(registerForMessagesAtBlackboardRequest);
await _activeMqConnector.SendAsync(registerPackage, _amqRoutes["ToBlackboard"], BrokerCommands.CONFIGURE_ROUTES);
logger.Trace($"Registration with Blackboard complete.");
}
internal async Task<ResponseWrapper> GetResponse(RoutingRequest request)
{
this.b.Path = request.UriPath;
Uri uri = this.b.Uri;
uri = uri.AddQuery("key", request.Key);
if (request.IncludeTraffic)
{
uri = uri.AddQuery("includeTraffic", "true");
if (request.AvoidTraffic)
uri = uri.AddQuery("avoidTraffic", "true");
}
if (request.AvoidTolls)
uri = uri.AddQuery("avoidTolls", "true");
if (!request.IncludeInstructions)
uri = uri.AddQuery("includeInstructions", "false");
var webRequest = WebRequest.Create(uri);
using (var webResponse = await webRequest.GetResponseAsync())
using (var responseStream = webResponse.GetResponseStream())
using (var ms = new MemoryStream())
{
await responseStream.CopyToAsync(ms);
string responseString = Encoding.UTF8.GetString(ms.ToArray());
Trace.WriteLine(responseString);
var rawResponse = fastJSON.JSON.ToObject<RoutingResponse>(responseString);
var wrappedResponse = new ResponseWrapper(request, rawResponse);
return wrappedResponse;
}
}
public RoutingResult GetResult(MapPos startPos, MapPos stopPos)
{
MapPosVector poses = new MapPosVector();
poses.Add(startPos);
poses.Add(stopPos);
RoutingRequest request = new RoutingRequest(BaseProjection, poses);
return(Service.CalculateRoute(request));
}
public async void InitConfigureRoutes()
{
logger.Debug($"InitConfigureRoutes.");
var registerForMessagesAtBlackboardRequest = new RoutingRequest()
{
Id = "ToHActor",
Path = KpuQueueString,
ContentTypes = new string[]
{
BrokerCommands.EXECUTE_REQUEST,
BrokerCommands.PACKAGE_REQUEST,
BrokerCommands.KPU_DEPLOYMENT,
},
};
var registerPackage = BreanosConnectors.SerializationHelper.Pack(registerForMessagesAtBlackboardRequest);
await receiveConnector.SendAsync(registerPackage, QueueString, BrokerCommands.CONFIGURE_ROUTES);
logger.Trace($"Registration with Blackboard for {QueueString} complete.");
var registerForMessagesAtBlackboardRequest2 = new RoutingRequest()
{
Id = "ToHActor",
Path = AssistantQueueString,
ContentTypes = new string[]
{
//BrokerCommands.KPU_DEPLOYMENT,
BrokerCommands.REQUESTKPUID,
//BrokerCommands.TELLKPUID
},
};
var registerPackage2 = BreanosConnectors.SerializationHelper.Pack(registerForMessagesAtBlackboardRequest2);
await receiveConnector.SendAsync(registerPackage2, QueueString, BrokerCommands.CONFIGURE_ROUTES);
var registerForMessagesAtBlackboardRequest3 = new RoutingRequest()
{
Id = "ToHActor",
Path = ManagementQueueString,
ContentTypes = new string[]
{
//BrokerCommands.KPU_DEPLOYMENT,
//BrokerCommands.REQUESTKPUID,
BrokerCommands.TELLKPUID
},
};
var registerPackage3 = BreanosConnectors.SerializationHelper.Pack(registerForMessagesAtBlackboardRequest2);
await receiveConnector.SendAsync(registerPackage3, QueueString, BrokerCommands.CONFIGURE_ROUTES);
logger.Trace($"Registration with Blackboard for {QueueString} complete.");
}
public RoutingResult GetResult(MapPos startPos, MapPos stopPos)
{
MapPosVector poses = new MapPosVector();
poses.Add(startPos);
poses.Add(stopPos);
RoutingRequest request = new RoutingRequest(Projection, poses);
RoutingResult result = null;
try
{
result = Service.CalculateRoute(request);
}
catch (Exception e)
{
Console.WriteLine("Exception calculating route: " + e.Message);
}
return(result);
}
public void showRoute(MapPos startPos, MapPos stopPos)
{
Log.Debug("calculating path " + startPos + " to " + stopPos);
if (!offlinePackageReady)
{
RunOnUiThread(() => {
Toast.MakeText(ApplicationContext, "Offline package is not ready, using online routing", ToastLength.Long).Show();
});
}
if (!shortestPathRunning)
{
shortestPathRunning = true;
long timeStart;
// run routing in background
Task.Run(() => {
timeStart = Java.Lang.JavaSystem.CurrentTimeMillis();
MapPosVector poses = new MapPosVector();
poses.Add(startPos);
poses.Add(stopPos);
RoutingRequest request = new RoutingRequest(baseProjection, poses);
RoutingResult result;
if (offlinePackageReady)
{
result = offlineRoutingService.CalculateRoute(request);
}
else
{
result = onlineRoutingService.CalculateRoute(request);
}
// now update response in UI thread
RunOnUiThread(() => {
if (result == null)
{
Toast.MakeText(ApplicationContext, "Routing failed", ToastLength.Long).Show();
shortestPathRunning = false;
return;
}
String routeText = "The route is " + (int)(result.TotalDistance / 100) / 10f
+ "km (" + secondsToHours((int)result.TotalTime)
+ ") calculation: " + (Java.Lang.JavaSystem.CurrentTimeMillis() - timeStart) + " ms";
Log.Info(routeText);
Toast.MakeText(ApplicationContext, routeText, ToastLength.Long).Show();
routeDataSource.RemoveAll();
startMarker.Visible = false;
routeDataSource.Add(createPolyline(startMarker.Geometry
.CenterPos, stopMarker.Geometry.CenterPos, result));
// add instruction markers
RoutingInstructionVector instructions = result.Instructions;
for (int i = 0; i < instructions.Count; i++)
{
RoutingInstruction instruction = instructions [i];
// Log.d(Const.LOG_TAG, instruction.toString());
createRoutePoint(result.Points [instruction.PointIndex], instruction.StreetName,
instruction.Time, instruction.Distance, instruction.Action, routeDataSource);
}
shortestPathRunning = false;
});
});
}
}
public RoutingResult GetResult(MapPos startPos, MapPos stopPos)
{
MapPosVector poses = new MapPosVector();
poses.Add(startPos);
poses.Add(stopPos);
RoutingRequest request = new RoutingRequest(BaseProjection, poses);
return Service.CalculateRoute(request);
}
public void ShowRoute(MapPos startPos, MapPos stopPos)
{
Log.Debug("calculating path " + startPos + " to " + stopPos);
if (!offlinePackageReady)
{
RunOnUiThread(() =>
{
string message = "Offline package is not ready, using online routing";
Toast.MakeText(ApplicationContext, message, ToastLength.Long).Show();
});
}
if (!shortestPathRunning)
{
shortestPathRunning = true;
long timeStart;
// run routing in background
Task.Run(() =>
{
timeStart = Java.Lang.JavaSystem.CurrentTimeMillis();
MapPosVector poses = new MapPosVector();
poses.Add(startPos);
poses.Add(stopPos);
RoutingRequest request = new RoutingRequest(BaseProjection, poses);
RoutingResult result;
if (offlinePackageReady)
{
result = offlineRoutingService.CalculateRoute(request);
}
else
{
result = onlineRoutingService.CalculateRoute(request);
}
// Now update response in UI thread
RunOnUiThread(() =>
{
if (result == null)
{
Alert("Routing failed");
shortestPathRunning = false;
return;
}
string distance = "The route is " + (int)(result.TotalDistance / 100) / 10f + "km";
string time = "(" + result.TotalTime.ConvertFromSecondsToHours() + ")";
string calculation = "| Calculation: " + (Java.Lang.JavaSystem.CurrentTimeMillis() - timeStart) + " ms";
Alert(distance + time + calculation);
routeDataSource.Clear();
startMarker.Visible = false;
Line line = CreatePolyline(startMarker.Geometry.CenterPos, stopMarker.Geometry.CenterPos, result);
routeDataSource.Add(line);
// Add instruction markers
RoutingInstructionVector instructions = result.Instructions;
for (int i = 0; i < instructions.Count; i++)
{
RoutingInstruction instruction = instructions[i];
MapPos position = result.Points[instruction.PointIndex];
CreateRoutePoint(position, instruction, routeDataSource);
}
shortestPathRunning = false;
});
});
}
}
public ResponseWrapper(RoutingRequest request, RoutingResponse rawResponse)
{
// TODO: Complete member initialization
this.request = request;
this.rawResponse = rawResponse;
}
public void ShowRoute(MapPos startPos, MapPos stopPos)
{
Log.Debug("calculating path " + startPos + " to " + stopPos);
if (!offlinePackageReady)
{
InvokeOnMainThread(() =>
{
string message = "Offline package is not ready. Using online routing";
Alert(message);
});
}
if (!shortestPathRunning)
{
shortestPathRunning = true;
long timeStart;
// run routing in background
System.Threading.Tasks.Task.Run(delegate
{
timeStart = DateTime.Now.ToUnixTime();
MapPosVector poses = new MapPosVector {
startPos, stopPos
};
RoutingRequest request = new RoutingRequest(BaseProjection, poses);
RoutingResult result;
if (offlinePackageReady)
{
result = offlineRoutingService.CalculateRoute(request);
}
else
{
result = onlineRoutingService.CalculateRoute(request);
}
// Now update response in UI thread
InvokeOnMainThread(delegate
{
if (result == null)
{
Alert("Routing failed");
shortestPathRunning = false;
return;
}
routeDataSource.Clear();
startMarker.Visible = false;
Line line = CreatePolyline(startMarker.Geometry.CenterPos, stopMarker.Geometry.CenterPos, result);
routeDataSource.Add(line);
// Add instruction markers
RoutingInstructionVector instructions = result.Instructions;
for (int i = 0; i < instructions.Count; i++)
{
RoutingInstruction instruction = instructions[i];
MapPos position = result.Points[instruction.PointIndex];
CreateRoutePoint(position, instruction, routeDataSource);
}
string distance = "The route is " + (int)(result.TotalDistance / 100) / 10f + "km";
string time = " (" + result.TotalTime.ConvertFromSecondsToHours() + ") ";
string calculation = "| Calculation: " + (DateTime.Now.ToUnixTime() - timeStart) + " ms";
Alert(distance + time + calculation);
shortestPathRunning = false;
});
});
}
}
