summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorScott Murray <scott.murray@konsulko.com>2019-08-30 11:40:23 -0400
committerScott Murray <scott.murray@konsulko.com>2019-08-30 11:42:40 -0400
commitf14ecdd52975ae365af5ed32648bf55dddacb8d9 (patch)
treee33d2af8d2e129b372caf34afac37366b641553a /src
parentdd61aa309b3a082488c9d3c383c1601fd3efbc2a (diff)
Initial check in
Initial check in of contents of the original repository: git://github.com/AGLExport/agl-service-navigation as of commit 1f1ffc92fcc882aa5e885badbc91a3384f5d77b1. Bug-AGL: SPEC-2787 Signed-off-by: Scott Murray <scott.murray@konsulko.com> Change-Id: I02d008ee73cdfd88f1e7587ee57101187b9c4d6d
Diffstat (limited to 'src')
-rw-r--r--src/analyze_request.cpp296
-rw-r--r--src/api.cpp419
-rw-r--r--src/binder_reply.cpp168
-rw-r--r--src/genivi_request.cpp350
-rw-r--r--src/traces.h38
5 files changed, 1271 insertions, 0 deletions
diff --git a/src/analyze_request.cpp b/src/analyze_request.cpp
new file mode 100644
index 0000000..593ed42
--- /dev/null
+++ b/src/analyze_request.cpp
@@ -0,0 +1,296 @@
+// Copyright 2017 AW SOFTWARE CO.,LTD
+// Copyright 2017 AISIN AW CO.,LTD
+
+#include "genivi/genivi-navicore-constants.h"
+#include "analyze_request.h"
+#include <stdio.h>
+#include <string.h>
+#include <json-c/json.h>
+#include <string>
+
+
+/**
+ * @brief Create arguments to pass to Genivi API GetPosition.
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] Params An array of key information you want to obtain
+ * @return Success or failure of processing
+ */
+bool AnalyzeRequest::CreateParamsGetPosition( const char* req_json_str, std::vector< int32_t >& Params)
+{
+ struct json_object *req_json = json_tokener_parse(req_json_str);
+ struct json_object* jValuesToReturn = NULL;
+ if( json_object_object_get_ex(req_json, "valuesToReturn", &jValuesToReturn) )
+ {
+ if( json_object_is_type(jValuesToReturn, json_type_array) )
+ {
+ for (int i = 0; i < json_object_array_length(jValuesToReturn); ++i)
+ {
+ struct json_object* j_elem = json_object_array_get_idx(jValuesToReturn, i);
+
+ // JSON type acquisition
+ if( json_object_is_type(j_elem, json_type_int ) )
+ {
+ int32_t req_key = json_object_get_int (j_elem);
+
+ // no supported.
+ if ((NAVICORE_TIMESTAMP == req_key) || (NAVICORE_SPEED == req_key))
+ {
+ continue;
+ }
+ Params.push_back(req_key);
+ }
+ else
+ {
+ fprintf(stdout, "key is not integer type.\n");
+ return false;
+ }
+ }
+ }
+ else
+ {
+ fprintf(stdout, "request is not array type.\n");
+ return false;
+ }
+ }
+ else
+ {
+ fprintf(stdout, "key valuesToReturn not found.\n");
+ return false;
+ }
+
+ return true;
+}
+
+
+/**
+ * @brief Create arguments to pass to Genivi API CreateRoute
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] sessionHdl Session handle
+ * @return Success or failure of processing
+ */
+bool AnalyzeRequest::CreateParamsCreateRoute( const char* req_json_str, uint32_t& sessionHdl )
+{
+ // Get sessionHandle information
+ return JsonObjectGetSessionHdl(req_json_str, sessionHdl);
+}
+
+
+/**
+ * @brief Create arguments to pass to Genivi API PauseSimulation
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] sessionHdl Session handle
+ * @return Success or failure of processing
+ */
+bool AnalyzeRequest::CreateParamsPauseSimulation( const char* req_json_str, uint32_t& sessionHdl )
+{
+ // Get sessionHandle information
+ return JsonObjectGetSessionHdl(req_json_str, sessionHdl);
+}
+
+
+/**
+ * @brief Create arguments to pass to Genivi API CreateRoute
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] sessionHdl Session handle
+ * @param[out] simuMode Simulation mode
+ * @return Success or failure of processing
+ */
+bool AnalyzeRequest::CreateParamsSetSimulationMode( const char* req_json_str, uint32_t& sessionHdl, bool& simuMode )
+{
+ bool ret = false;
+ struct json_object *sess = NULL;
+ struct json_object *simu = NULL;
+
+ struct json_object *req_json = json_tokener_parse(req_json_str);
+ if ((json_object_object_get_ex(req_json, "sessionHandle", &sess)) &&
+ (json_object_object_get_ex(req_json, "simulationMode", &simu)))
+ {
+ if (json_object_is_type(sess, json_type_int) &&
+ json_object_is_type(simu, json_type_boolean))
+ {
+ sessionHdl = json_object_get_int(sess);
+ simuMode = json_object_get_int(simu);
+ ret = true;
+ }
+ else
+ {
+ fprintf(stdout, "key is invalid type.\n");
+ }
+ }
+ else
+ {
+ fprintf(stdout, "key sessionHandle or simulationMode not found.\n");
+ }
+
+ return ret;
+}
+
+
+/**
+ * @brief Create arguments to pass to Genivi API CancelRouteCalculation
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] sessionHdl Session handle
+ * @param[out] routeHdl Route handle
+ * @return Success or failure of processing
+ */
+bool AnalyzeRequest::CreateParamsCancelRouteCalculation( const char* req_json_str, uint32_t& sessionHdl, uint32_t& routeHdl )
+{
+ // Get sessionHandle, RouteHandle
+ return JsonObjectGetSessionHdlRouteHdl(req_json_str, sessionHdl, routeHdl);
+}
+
+
+/**
+ * @brief Create arguments to pass to Genivi API SetWaypoints
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] sessionHdl Session handle
+ * @param[out] routeHdl Route handle
+ * @param[out] currentPos Whether or not to draw a route from the position of the vehicle
+ * @param[out] waypointsList Destination coordinates
+ * @return Success or failure of processing
+ */
+bool AnalyzeRequest::CreateParamsSetWaypoints( const char* req_json_str, uint32_t& sessionHdl, uint32_t& routeHdl,
+ bool& currentPos, std::vector<Waypoint>& waypointsList )
+{
+ bool ret = false;
+ struct json_object *sess = NULL;
+ struct json_object *rou = NULL;
+ struct json_object *current = NULL;
+ struct json_object *wpl = NULL;
+
+ struct json_object *req_json = json_tokener_parse(req_json_str);
+ if ((json_object_object_get_ex(req_json, "sessionHandle", &sess)) &&
+ (json_object_object_get_ex(req_json, "route", &rou)) &&
+ (json_object_object_get_ex(req_json, "startFromCurrentPosition", &current)) &&
+ (json_object_object_get_ex(req_json, "", &wpl)))
+ {
+ if (json_object_is_type(sess, json_type_int) &&
+ json_object_is_type(rou, json_type_int) &&
+ json_object_is_type(current, json_type_boolean) &&
+ json_object_is_type(wpl, json_type_array))
+ {
+ sessionHdl = json_object_get_int(sess);
+ routeHdl = json_object_get_int(rou);
+ currentPos = json_object_get_boolean(current);
+
+ // Get latitude, longitude
+ for (int i = 0; i < json_object_array_length(wpl); ++i)
+ {
+ struct json_object *array = json_object_array_get_idx(wpl, i);
+ struct json_object *lati = NULL;
+ struct json_object *longi = NULL;
+
+ if (json_object_object_get_ex(array, "latitude", &lati) &&
+ json_object_object_get_ex(array, "longitude", &longi)) {
+
+ double latitude = json_object_get_double(lati);
+ double longitude = json_object_get_double(longi);
+ Waypoint destWp(latitude, longitude);
+ waypointsList.push_back(destWp);
+ ret = true;
+ }
+ else
+ {
+ fprintf(stdout, "key latitude or longitude not found.\n");
+ }
+ }
+ }
+ else
+ {
+ fprintf(stdout, "key is invalid type.\n");
+ }
+ }
+ else
+ {
+ fprintf(stdout, "key valuesToReturn not found.\n");
+ }
+
+ return ret;
+}
+
+
+/**
+ * @brief Create arguments to pass to Genivi API CalculateRoute
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] sessionHdl Session handle
+ * @param[out] routeHdl Route handle
+ * @return Success or failure of processing
+ */
+bool AnalyzeRequest::CreateParamsCalculateRoute( const char* req_json_str, uint32_t& sessionHdl, uint32_t& routeHdl )
+{
+ // Get sessionHandle, RouteHandle
+ return JsonObjectGetSessionHdlRouteHdl(req_json_str, sessionHdl, routeHdl);
+}
+
+
+/**
+ * @brief Get session handle and route handle information from JSON
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] Session handle value
+ * @return Success or failure of processing
+ */
+
+bool AnalyzeRequest::JsonObjectGetSessionHdl( const char* req_json_str, uint32_t& sessionHdl)
+{
+ bool ret = false;
+ struct json_object *sess = NULL;
+
+ struct json_object *req_json = json_tokener_parse(req_json_str);
+ if (json_object_object_get_ex(req_json, "sessionHandle", &sess))
+ {
+ if (json_object_is_type(sess, json_type_int))
+ {
+ sessionHdl = json_object_get_int(sess);
+ ret = true;
+ }
+ else
+ {
+ fprintf(stdout, "key is not integer type.\n");
+ }
+ }
+ else
+ {
+ fprintf(stdout, "key sessionHandle not found.\n");
+ }
+
+ return ret;
+}
+
+
+/**
+ * @brief Get session handle and route handle information from JSON
+ * @param[in] req_json_str JSON request from BinderClient
+ * @param[out] Session handle value
+ * @param[out] Route handle value
+ * @return Success or failure of processing
+ */
+
+bool AnalyzeRequest::JsonObjectGetSessionHdlRouteHdl( const char* req_json_str, uint32_t& sessionHdl, uint32_t& routeHdl)
+{
+ bool ret = false;
+ struct json_object *sess = NULL;
+ struct json_object *rou = NULL;
+
+ struct json_object *req_json = json_tokener_parse(req_json_str);
+ if ((json_object_object_get_ex(req_json, "sessionHandle", &sess)) &&
+ (json_object_object_get_ex(req_json, "route", &rou)))
+ {
+ if (json_object_is_type(sess, json_type_int) &&
+ json_object_is_type(rou, json_type_int))
+ {
+ sessionHdl = json_object_get_int(sess);
+ routeHdl = json_object_get_int(rou);
+ ret = true;
+ }
+ else
+ {
+ fprintf(stdout, "key is not integer type.\n");
+ }
+ }
+ else
+ {
+ fprintf(stdout, "key sessionHandle or route not found.\n");
+ }
+
+ return ret;
+}
diff --git a/src/api.cpp b/src/api.cpp
new file mode 100644
index 0000000..bf04453
--- /dev/null
+++ b/src/api.cpp
@@ -0,0 +1,419 @@
+// Copyright 2017 AW SOFTWARE CO.,LTD
+// Copyright 2017 AISIN AW CO.,LTD
+
+#include <string.h>
+
+#include "binder_reply.h"
+#include "genivi_request.h"
+#include "analyze_request.h"
+#include "genivi/genivi-navicore-constants.h"
+
+#define AFB_BINDING_VERSION 2
+
+extern "C" {
+ #include <afb/afb-binding.h>
+}
+
+/**
+ * Variable declaration
+ */
+GeniviRequest* geniviRequest; // Send request to Genivi
+BinderReply* binderReply; // Convert Genivi response result to json format
+AnalyzeRequest* analyzeRequest; // Analyze BinderClient's request and create arguments to pass to GeniviAPI
+
+/**
+ * @brief navicore_getposition request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicoreGetPosition(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_getposition");
+
+ // Request of Json format request
+ json_object* req_json = afb_req_json(req);
+ const char* req_json_str = json_object_to_json_string(req_json);
+ AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
+
+ // Request analysis and create arguments to pass to Genivi
+ std::vector< int32_t > Params;
+ if( !analyzeRequest->CreateParamsGetPosition( req_json_str, Params ))
+ {
+ afb_req_fail(req, "failed", "navicore_getposition Bad Request");
+ return;
+ }
+
+ // GENIVI API call
+ std::map< int32_t, double > posList = geniviRequest->NavicoreGetPosition( Params );
+
+ // Convert to json style response
+ APIResponse response = binderReply->ReplyNavicoreGetPosition( posList );
+
+ // On success
+ if(response.isSuccess)
+ {
+ AFB_REQ_NOTICE(req, "res_json_str = %s", json_object_to_json_string(response.json_data));
+ // Return success to BinderClient
+ afb_req_success(req, response.json_data, "navicore_getposition");
+ }
+ else
+ {
+ AFB_REQ_ERROR(req, "%s - %s:%d", response.errMessage.c_str(), __FILE__, __LINE__);
+ afb_req_fail(req, "failed", "navicore_getposition Bad Request");
+ }
+
+ // Json object release
+ json_object_put(response.json_data);
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief navicore_getallroutes request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicoreGetAllRoutes(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_getallroutes");
+
+ // No request information in json format
+ AFB_REQ_NOTICE(req, "req_json_str = none");
+
+ // GENEVI API call
+ std::vector< uint32_t > allRoutes = geniviRequest->NavicoreGetAllRoutes();
+
+ // Convert to json style response
+ APIResponse response = binderReply->ReplyNavicoreGetAllRoutes( allRoutes );
+
+ // On success
+ if(response.isSuccess)
+ {
+ AFB_REQ_NOTICE(req, "res_json_str = %s", json_object_to_json_string(response.json_data));
+ // Return success to BinderClient
+ afb_req_success(req, response.json_data, "navicore_getallroutes");
+ }
+ else
+ {
+ AFB_REQ_ERROR(req, "%s - %s:%d", response.errMessage.c_str(), __FILE__, __LINE__);
+ afb_req_fail(req, "failed", "navicore_getallroutes Bad Request");
+ }
+
+ // json object release
+ json_object_put(response.json_data);
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief navicore_createroute request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicoreCreateRoute(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s ", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_createroute");
+
+ // Request of json format request
+ json_object* req_json = afb_req_json(req);
+ const char* req_json_str = json_object_to_json_string(req_json);
+ AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
+
+ // Request analysis and create arguments to pass to Genivi
+ uint32_t sessionHdl = 0;
+ if( !analyzeRequest->CreateParamsCreateRoute( req_json_str, sessionHdl ))
+ {
+ afb_req_fail(req, "failed", "navicore_createroute Bad Request");
+ return;
+ }
+
+ // GENEVI API call
+ uint32_t routeHdl = geniviRequest->NavicoreCreateRoute( sessionHdl );
+
+ // Convert to json style response
+ APIResponse response = binderReply->ReplyNavicoreCreateRoute( routeHdl );
+
+ // On success
+ if(response.isSuccess)
+ {
+ AFB_REQ_NOTICE(req, "res_json_str = %s", json_object_to_json_string(response.json_data));
+ // Return success to BinderClient
+ afb_req_success(req, response.json_data, "navicore_createroute");
+ }
+ else
+ {
+ AFB_REQ_ERROR(req, "%s - %s:%d", response.errMessage.c_str(), __FILE__, __LINE__);
+ afb_req_fail(req, "failed", "navicore_createroute Bad Request");
+ }
+
+ // json object release
+ json_object_put(response.json_data);
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief navicore_pausesimulation request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicorePauseSimulation(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_pausesimulation");
+
+ // Request of json format request
+ json_object* req_json = afb_req_json(req);
+ const char* req_json_str = json_object_to_json_string(req_json);
+ AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
+
+ // Request analysis and create arguments to pass to Genivi
+ uint32_t sessionHdl = 0;
+ if( !analyzeRequest->CreateParamsPauseSimulation( req_json_str, sessionHdl ))
+ {
+ afb_req_fail(req, "failed", "navicore_pausesimulation Bad Request");
+ return;
+ }
+
+ // GENEVI API call
+ geniviRequest->NavicorePauseSimulation( sessionHdl );
+
+ // No reply unnecessary API for conversion to json format response is unnecessary
+ AFB_REQ_NOTICE(req, "res_json_str = none");
+
+ // Return success to BinderClient
+ afb_req_success(req, NULL, "navicore_pausesimulation");
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief navicore_setsimulationmode request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicoreSetSimulationMode(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_setsimulationmode");
+
+ // Request of json format request
+ json_object* req_json = afb_req_json(req);
+ const char* req_json_str = json_object_to_json_string(req_json);
+ AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
+
+ // Request analysis and create arguments to pass to Genivi
+ uint32_t sessionHdl = 0;
+ bool simuMode = false;
+ if( !analyzeRequest->CreateParamsSetSimulationMode( req_json_str, sessionHdl, simuMode ))
+ {
+ afb_req_fail(req, "failed", "navicore_setsimulationmode Bad Request");
+ return;
+ }
+
+ // GENEVI API call
+ geniviRequest->NavicoreSetSimulationMode( sessionHdl, simuMode );
+
+ // No reply unnecessary API for conversion to json format response is unnecessary
+ AFB_REQ_NOTICE(req, "res_json_str = none");
+
+ // Return success to BinderClient
+ afb_req_success(req, NULL, "navicore_setsimulationmode");
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief navicore_cancelroutecalculation request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicoreCancelRouteCalculation(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_cancelroutecalculation");
+
+ // Request of Json format request
+ json_object* req_json = afb_req_json(req);
+ const char* req_json_str = json_object_to_json_string(req_json);
+ AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
+
+ // Request analysis and create arguments to pass to Genivi
+ uint32_t sessionHdl = 0;
+ uint32_t routeHdl = 0;
+ if( !analyzeRequest->CreateParamsCancelRouteCalculation( req_json_str, sessionHdl, routeHdl ))
+ {
+ afb_req_fail(req, "failed", "navicore_cancelroutecalculation Bad Request");
+ return;
+ }
+
+ // GENEVI API call
+ geniviRequest->NavicoreCancelRouteCalculation( sessionHdl, routeHdl );
+
+ // No reply unnecessary API for conversion to json format response is unnecessary
+ AFB_REQ_NOTICE(req, "res_json_str = none");
+
+ // Return success to BinderClient
+ afb_req_success(req, NULL, "navicore_cancelroutecalculation");
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief navicore_setwaypoints request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicoreWaypoints(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_setwaypoints");
+
+ // Request of Json format request
+ json_object* req_json = afb_req_json(req);
+ const char* req_json_str = json_object_to_json_string(req_json);
+ AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
+
+ // Request analysis and create arguments to pass to Genivi
+ uint32_t sessionHdl = 0;
+ uint32_t routeHdl = 0;
+ bool currentPos = false;
+ std::vector<Waypoint> waypointsList;
+ if( !analyzeRequest->CreateParamsSetWaypoints( req_json_str, sessionHdl, routeHdl, currentPos, waypointsList ))
+ {
+ afb_req_fail(req, "failed", "navicore_setwaypoints Bad Request");
+ return;
+ }
+
+ // GENEVI API call
+ geniviRequest->NavicoreSetWaypoints( sessionHdl, routeHdl, currentPos, waypointsList );
+
+ // No reply unnecessary API for conversion to json format response is unnecessary
+ AFB_REQ_NOTICE(req, "res_json_str = none");
+
+ // Return success to BinderClient
+ afb_req_success(req, NULL, "navicore_setwaypoints");
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief navicore_calculateroute request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicoreCalculateRoute(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_calculateroute");
+
+ // Request of Json format request
+ json_object* req_json = afb_req_json(req);
+ const char* req_json_str = json_object_to_json_string(req_json);
+ AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
+
+ // Request analysis and create arguments to pass to Genivi
+ uint32_t sessionHdl = 0;
+ uint32_t routeHdl = 0;
+ if( !analyzeRequest->CreateParamsCalculateRoute( req_json_str, sessionHdl, routeHdl ))
+ {
+ afb_req_fail(req, "failed", "navicore_calculateroute Bad Request");
+ return;
+ }
+
+ // GENEVI API call
+ geniviRequest->NavicoreCalculateRoute( sessionHdl, routeHdl );
+
+ // No reply unnecessary API for conversion to json format response is unnecessary
+ AFB_REQ_NOTICE(req, "res_json_str = none");
+
+ // Return success to BinderClient
+ afb_req_success(req, NULL, "navicore_calculateroute");
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief navicore_getallsessions request callback
+ * @param[in] req Request from client
+ */
+void OnRequestNavicoreGetAllSessions(afb_req req)
+{
+ AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
+ AFB_REQ_DEBUG(req, "request navicore_getallsessions");
+
+ // No request information in Json format
+ AFB_REQ_NOTICE(req, "req_json_str = none");
+
+ // GENEVI API call
+ std::map<uint32_t, std::string> allSessions = geniviRequest->NavicoreGetAllSessions();
+
+ // Convert to json style response
+ APIResponse response = binderReply->ReplyNavicoreGetAllSessions( allSessions );
+
+ // On success
+ if(response.isSuccess)
+ {
+ AFB_REQ_NOTICE(req, "res_json_str = %s", json_object_to_json_string(response.json_data));
+ // Return success to BinderClient
+ afb_req_success(req, response.json_data, "navicore_getallsessions");
+ }
+ else
+ {
+ AFB_REQ_ERROR(req, "%s - %s:%d", response.errMessage.c_str(), __FILE__, __LINE__);
+ afb_req_fail(req, "failed", "navicore_getallsessions Bad Request");
+ }
+
+ // json object release
+ json_object_put(response.json_data);
+
+ AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
+}
+
+
+/**
+ * @brief Callback called at service startup
+ */
+int Init()
+{
+ // Create instance
+ geniviRequest = new GeniviRequest();
+ binderReply = new BinderReply();
+ analyzeRequest = new AnalyzeRequest();
+
+ return 0;
+}
+
+/**
+ * @brief API definition
+ */
+const afb_verb_v2 verbs[] =
+{
+ { verb : "navicore_getposition", callback : OnRequestNavicoreGetPosition },
+ { verb : "navicore_getallroutes", callback : OnRequestNavicoreGetAllRoutes },
+ { verb : "navicore_createroute", callback : OnRequestNavicoreCreateRoute },
+ { verb : "navicore_pausesimulation", callback : OnRequestNavicorePauseSimulation },
+ { verb : "navicore_setsimulationmode", callback : OnRequestNavicoreSetSimulationMode },
+ { verb : "navicore_cancelroutecalculation", callback : OnRequestNavicoreCancelRouteCalculation },
+ { verb : "navicore_setwaypoints", callback : OnRequestNavicoreWaypoints },
+ { verb : "navicore_calculateroute", callback : OnRequestNavicoreCalculateRoute },
+ { verb : "navicore_getallsessions", callback : OnRequestNavicoreGetAllSessions },
+ { verb : NULL }
+};
+
+/**
+ * @brief Service definition
+ */
+const afb_binding_v2 afbBindingV2 =
+{
+ "naviapi",
+ "",
+ "",
+ verbs,
+ NULL,
+ Init
+};
+
diff --git a/src/binder_reply.cpp b/src/binder_reply.cpp
new file mode 100644
index 0000000..172a22a
--- /dev/null
+++ b/src/binder_reply.cpp
@@ -0,0 +1,168 @@
+// Copyright 2017 AW SOFTWARE CO.,LTD
+// Copyright 2017 AISIN AW CO.,LTD
+
+#include "binder_reply.h"
+#include "genivi/genivi-navicore-constants.h"
+
+/**
+ * @brief GeniviAPI GetPosition call
+ * @param[in] posList Map information on key and value of information acquired from Genivi
+ * @return Response information
+ */
+APIResponse BinderReply::ReplyNavicoreGetPosition( std::map<int32_t, double>& posList )
+{
+ APIResponse response = {0};
+
+ // Json information to return as a response
+ struct json_object* response_json = json_object_new_array();
+ std::map<int32_t, double>::iterator it;
+
+ // If the argument map is empty return
+ if(posList.empty())
+ {
+ response.isSuccess = false;
+ response.errMessage = "posList is empty";
+ response.json_data = response_json;
+ return response;
+ }
+
+ // Make the passed Genivi response json format
+ for (it = posList.begin(); it != posList.end(); it++)
+ {
+ struct json_object* obj = json_object_new_object();
+
+ switch(it->first)
+ {
+ case NAVICORE_LATITUDE:
+ json_object_object_add(obj, "key", json_object_new_int(NAVICORE_LATITUDE));
+ json_object_object_add(obj, "value", json_object_new_double(it->second) );
+ json_object_array_add(response_json, obj);
+ break;
+
+ case NAVICORE_LONGITUDE:
+ json_object_object_add(obj, "key", json_object_new_int(NAVICORE_LONGITUDE));
+ json_object_object_add(obj, "value", json_object_new_double(it->second));
+ json_object_array_add(response_json, obj);
+ break;
+
+ case NAVICORE_HEADING:
+ json_object_object_add(obj, "key", json_object_new_int(NAVICORE_HEADING));
+ json_object_object_add(obj, "value", json_object_new_boolean (it->second));
+ json_object_array_add(response_json, obj);
+ break;
+#if 0
+ // no support
+ case NAVICORE_TIMESTAMP:
+ json_object_object_add(obj, "key", json_object_new_int(NAVICORE_TIMESTAMP));
+ json_object_object_add(obj, "value", json_object_new_int(it->second));
+ json_object_array_add(response_json, obj);
+ break;
+
+ // no support
+ case NAVICORE_SPEED:
+ json_object_object_add(obj, "key", json_object_new_int(NAVICORE_SPEED));
+ json_object_object_add(obj, "value", json_object_new_int(it->second));
+ json_object_array_add(response_json, obj);
+ break;
+#endif
+
+ case NAVICORE_SIMULATION_MODE:
+ json_object_object_add(obj, "key", json_object_new_int(NAVICORE_SIMULATION_MODE));
+ json_object_object_add(obj, "value", json_object_new_boolean (it->second));
+ json_object_array_add(response_json, obj);
+ break;
+
+ default:
+ fprintf(stderr, "Unknown key.");
+ json_object_put(obj);
+ break;
+ }
+ }
+
+ response.json_data = response_json;
+ response.isSuccess = true;
+ return response;
+}
+
+/**
+ * @brief GeniviAPI GetAllRoutes call
+ * @param[in] allRoutes Route handle information
+ * @return Response information
+ */
+APIResponse BinderReply::ReplyNavicoreGetAllRoutes( std::vector< uint32_t > &allRoutes )
+{
+ APIResponse response = {0};
+
+ // Json information to return as a response
+ struct json_object* response_json = json_object_new_array();
+
+ if (0 < allRoutes.size())
+ {
+ std::vector< uint32_t >::iterator it;
+
+ for (it = allRoutes.begin(); it != allRoutes.end(); it++)
+ {
+ struct json_object* obj = json_object_new_object();
+ json_object_object_add(obj, "route", json_object_new_int(*it));
+ json_object_array_add(response_json, obj);
+ }
+ }
+
+ response.json_data = response_json;
+ response.isSuccess = true;
+ return response;
+}
+
+/**
+ * @brief GeniviAPI CreateRoute call
+ * @param[in] route Route handle
+ * @return Response information
+ */
+APIResponse BinderReply::ReplyNavicoreCreateRoute( uint32_t route )
+{
+ APIResponse response;
+
+ // Json information to return as a response
+ struct json_object* response_json = json_object_new_object();
+ json_object_object_add(response_json, "route", json_object_new_int(route));
+
+ response.json_data = response_json;
+ response.isSuccess = true;
+ return response;
+}
+
+/**
+ * @brief GeniviAPI GetAllSessions call
+ * @param[in] allSessions Map information on key and value of information acquired from Genivi
+ * @return Response information
+ */
+APIResponse BinderReply::ReplyNavicoreGetAllSessions( std::map<uint32_t, std::string> &allSessions )
+{
+ APIResponse response = {0};
+
+ // Json information to return as a response
+ struct json_object* response_json = json_object_new_array();
+ std::map<uint32_t, std::string>::iterator it;
+
+ for (it = allSessions.begin(); it != allSessions.end(); it++)
+ {
+ struct json_object* obj = json_object_new_object();
+
+ if (NAVICORE_INVALID != it->first)
+ {
+ json_object_object_add(obj, "sessionHandle", json_object_new_int(it->first));
+ json_object_object_add(obj, "client", json_object_new_string(it->second.c_str()));
+ json_object_array_add(response_json, obj);
+ }
+ else
+ {
+ fprintf(stderr, "invalid key.");
+ json_object_put(obj);
+ }
+ }
+
+ response.json_data = response_json;
+ response.isSuccess = true;
+ return response;
+}
+
diff --git a/src/genivi_request.cpp b/src/genivi_request.cpp
new file mode 100644
index 0000000..a485667
--- /dev/null
+++ b/src/genivi_request.cpp
@@ -0,0 +1,350 @@
+// Copyright 2017 AW SOFTWARE CO.,LTD
+// Copyright 2017 AISIN AW CO.,LTD
+
+#include "genivi/navicore.h"
+#include "genivi/genivi-navicore-constants.h"
+#include "genivi_request.h"
+#include <stdio.h>
+#include <exception>
+#include <dbus-c++-1/dbus-c++/dbus.h>
+
+/**
+ * @brief Destructor
+ */
+GeniviRequest::~GeniviRequest()
+{
+ delete (Navicore*)navicore_;
+ navicore_ = NULL;
+}
+
+/**
+ * @brief DBus session creation
+ */
+void GeniviRequest::CreateDBusSession( )
+{
+ try
+ {
+ static DBus::BusDispatcher dispatcher;
+ DBus::default_dispatcher = &dispatcher;
+ DBus::Connection conn = DBus::Connection::SessionBus();
+
+ navicore_ = new Navicore(conn, "/org/genivi/navicore", "org.agl.naviapi");
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+}
+
+/**
+ * @brief Check connection status
+ * @return Presence / absence of connection
+ */
+bool GeniviRequest::CheckSession()
+{
+ if(this->navicore_ == NULL)
+ {
+ this->CreateDBusSession();
+ }
+
+ try
+ {
+ // Get connection status
+ DBus::Connection conn = ((Navicore*)navicore_)->conn();
+ bool isConnect = conn.connected();
+
+ // If it is not connected, it issues an error
+ if(!isConnect)
+ {
+ fprintf(stderr, "Service has no session.\n");
+ }
+
+ return isConnect;
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ return false;
+ }
+}
+
+/**
+ * @brief Call GeniviAPI GetPosition to get information
+ * @param[in] valuesToReturn Key arrangement of information acquired from Genivi
+ * @return Map information on key and value of information acquired from Genivi
+ */
+std::map< int32_t, double > GeniviRequest::NavicoreGetPosition( const std::vector< int32_t >& valuesToReturn )
+{
+ std::map< int32_t, double > ret;
+
+ if( !CheckSession() )
+ {
+ return ret;
+ }
+
+ try
+ {
+ std::map< int32_t, ::DBus::Struct< uint8_t, ::DBus::Variant > >::iterator it;
+ std::map< int32_t, ::DBus::Struct< uint8_t, ::DBus::Variant > > PosList =
+ ((Navicore*)navicore_)->GetPosition(valuesToReturn);
+ for (it = PosList.begin(); it != PosList.end(); it++)
+ {
+ if (it->first == NAVICORE_LATITUDE || it->second._1 == NAVICORE_LATITUDE)
+ {
+ ret[it->first] = it->second._2.reader().get_double();
+ }
+ else if (it->first == NAVICORE_LONGITUDE || it->second._1 == NAVICORE_LONGITUDE)
+ {
+ ret[it->first] = it->second._2.reader().get_double();
+ }
+ else if (it->first == NAVICORE_HEADING || it->second._1 == NAVICORE_HEADING)
+ {
+ ret[it->first] = it->second._2.reader().get_uint32();
+ }
+#if 0 // no supported
+ else if (it->first == NAVICORE_TIMESTAMP || it->second._1 == NAVICORE_TIMESTAMP)
+ {
+ ret[it->first] = it->second._2.reader().get_uint32();
+ }
+ else if (it->first == NAVICORE_SPEED || it->second._1 == NAVICORE_SPEED)
+ {
+ ret[it->first] = it->second._2.reader().get_int32();
+ }
+#endif
+ else if (it->first == NAVICORE_SIMULATION_MODE || it->second._1 == NAVICORE_SIMULATION_MODE)
+ {
+ ret[it->first] = it->second._2.reader().get_bool();
+ }
+ }
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+
+ return ret;
+}
+
+/**
+ * @brief Call GeniviAPI GetPosition to get information
+ * @return Route handle acquired from Genivi
+ */
+std::vector< uint32_t > GeniviRequest::NavicoreGetAllRoutes( void )
+{
+ if( !CheckSession() )
+ {
+ std::vector< uint32_t > no_route;
+ return no_route;
+ }
+
+ std::vector< uint32_t > allRoutes;
+ try
+ {
+ allRoutes = ((Navicore*)navicore_)->GetAllRoutes();
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+
+ return allRoutes;
+}
+
+
+/**
+ * @brief Call GeniviAPI GetPosition to get information
+ * @param[in] sessionHandle Session handle
+ * @return Route handle acquired from Genivi
+ */
+uint32_t GeniviRequest::NavicoreCreateRoute( const uint32_t& sessionHandle )
+{
+ if( !CheckSession() )
+ {
+ return 0;
+ }
+
+ uint32_t routeHandle = 0;
+ try
+ {
+ routeHandle = ((Navicore*)navicore_)->CreateRoute(sessionHandle);
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+
+ return routeHandle;
+}
+
+/**
+ * @brief Call GeniviAPI PauseSimulation
+ * @param[in] sessionHandle Session handle
+ */
+void GeniviRequest::NavicorePauseSimulation( const uint32_t& sessionHandle )
+{
+ if( !CheckSession() )
+ {
+ return;
+ }
+
+ try
+ {
+ ((Navicore*)navicore_)->PauseSimulation(sessionHandle);
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+}
+
+
+/**
+ * @brief Call GeniviAPI SetSimulationMode
+ * @param[in] sessionHandle Session handle
+ * @param[in] activate Simulation mode enabled / disabled
+ */
+void GeniviRequest::NavicoreSetSimulationMode( const uint32_t& sessionHandle, const bool& activate )
+{
+ if( !CheckSession() )
+ {
+ return;
+ }
+
+ try
+ {
+ ((Navicore*)navicore_)->SetSimulationMode(sessionHandle, activate);
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+}
+
+
+/**
+ * @brief Call GeniviAPI SetSimulationMode
+ * @param[in] sessionHandle Session handle
+ * @param[in] routeHandle Route handle
+ */
+void GeniviRequest::NavicoreCancelRouteCalculation( const uint32_t& sessionHandle, const uint32_t& routeHandle )
+{
+ if( !CheckSession() )
+ {
+ return;
+ }
+
+ try
+ {
+ ((Navicore*)navicore_)->CancelRouteCalculation(sessionHandle, routeHandle);
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+}
+
+/**
+ * @brief Call GeniviAPI SetWaypoints
+ * @param[in] sessionHandle Session handle
+ * @param[in] routeHandle Route handle
+ * @param[in] startFromCurrentPosition Whether or not to draw a route from the position of the vehicle
+ * @param[in] waypointsList Destination coordinates
+ */
+void GeniviRequest::NavicoreSetWaypoints( const uint32_t& sessionHandle, const uint32_t& routeHandle,
+ const bool& startFromCurrentPosition, const std::vector<Waypoint>& waypointsList )
+{
+ if( !CheckSession() )
+ {
+ return;
+ }
+
+ std::vector<Waypoint>::const_iterator it;
+ std::vector< std::map< int32_t, ::DBus::Struct< uint8_t, ::DBus::Variant > > > wpl;
+
+ fprintf(stdout, "session: %d, route: %d, startFromCurrentPosition: %d\n",
+ sessionHandle, routeHandle, startFromCurrentPosition);
+
+ for (it = waypointsList.begin(); it != waypointsList.end(); it++)
+ {
+ std::map< int32_t, ::DBus::Struct< uint8_t, ::DBus::Variant > > Point;
+ ::DBus::Struct< uint8_t, ::DBus::Variant > VarLat, VarLon;
+
+ VarLat._1 = NAVICORE_LATITUDE;
+ VarLat._2.writer().append_double(std::get<0>(*it));
+ fprintf(stdout, "VarLat._1 : %x, VarLat._2 : %lf\n", VarLat._1, VarLat._2.reader().get_double());
+
+ VarLon._1 = NAVICORE_LONGITUDE;
+ VarLon._2.writer().append_double(std::get<1>(*it));
+ fprintf(stdout, "VarLon._1 : %x, VarLon._2 : %lf\n", VarLon._1, VarLon._2.reader().get_double());
+
+ Point[NAVICORE_LATITUDE] = VarLat;
+ Point[NAVICORE_LONGITUDE] = VarLon;
+
+ wpl.push_back(Point);
+ }
+
+ try
+ {
+ ((Navicore*)navicore_)->SetWaypoints(sessionHandle, routeHandle, startFromCurrentPosition, wpl);
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+}
+
+/**
+ * @brief Call GeniviAPI CalculateRoute
+ * @param[in] sessionHandle Session handle
+ * @param[in] routeHandle Route handle
+ */
+void GeniviRequest::NavicoreCalculateRoute( const uint32_t& sessionHandle, const uint32_t& routeHandle )
+{
+ if( !CheckSession() )
+ {
+ return;
+ }
+
+ try
+ {
+ ((Navicore*)navicore_)->CalculateRoute(sessionHandle, routeHandle);
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+}
+
+
+/**
+ * @brief Call GeniviAPI CalculateRoute
+ * @return Map information on key and value of information acquired from Genivi
+ */
+std::map<uint32_t, std::string> GeniviRequest::NavicoreGetAllSessions()
+{
+ std::map<uint32_t, std::string> ret;
+
+ if( !CheckSession() )
+ {
+ return ret;
+ }
+
+ std::vector< ::DBus::Struct< uint32_t, std::string > > ncAllSessions;
+ std::vector< ::DBus::Struct< uint32_t, std::string > >::iterator it;
+
+ try
+ {
+ ncAllSessions = ((Navicore*)navicore_)->GetAllSessions();
+ for (it = ncAllSessions.begin(); it != ncAllSessions.end(); it++)
+ {
+ ret[it->_1] = it->_2;
+ }
+ }
+ catch(const std::exception& e)
+ {
+ fprintf(stderr, "Error:%s\n", e.what());
+ }
+
+ return ret;
+}
+
diff --git a/src/traces.h b/src/traces.h
new file mode 100644
index 0000000..a1f96ec
--- /dev/null
+++ b/src/traces.h
@@ -0,0 +1,38 @@
+// Copyright 2017 AISIN AW CO.,LTD
+
+#ifndef __TRACE_H__
+#define __TRACE_H__
+
+#include <stdio.h>
+
+#define BLACK "\033[30m"
+#define RED "\033[31m"
+#define GREEN "\033[32m"
+#define YELLOW "\033[33m"
+#define BLUE "\033[34m"
+#define PURPLE "\033[35m"
+#define DGREEN "\033[6m"
+#define WHITE "\033[7m"
+#define CYAN "\x1b[36m"
+#define NONE "\033[0m"
+
+#ifdef NDEBUG
+
+#define TRACE_DEBUG_JSON(fmt, args...)
+#define TRACE_DEBUG(fmt, args...)
+#define TRACE_INFO(fmt, args...)
+#define TRACE_WARN(fmt, args...)
+#define TRACE_ERROR(fmt, args...)
+
+#else
+
+#define TRACE_DEBUG(fmt, args...) do { fprintf(stderr, "[%s:%d] " CYAN "DEBUG" NONE ": " fmt "\n", __func__, __LINE__, ##args); } while(0)
+#define TRACE_INFO(fmt, args...) do { fprintf(stderr, "[%s:%d] " GREEN "INFO" NONE ": " fmt "\n", __func__, __LINE__, ##args); } while(0)
+#define TRACE_WARN(fmt, args...) do { fprintf(stderr, "[%s:%d] " YELLOW "WARN" NONE": " fmt "\n", __func__, __LINE__, ##args); } while(0)
+#define TRACE_ERROR(fmt, args...) do { fprintf(stderr, "[%s:%d] " RED "ERROR" NONE ": " fmt "\n", __func__, __LINE__, ##args); } while(0)
+
+#define TRACE_DEBUG_JSON(fmt, args...)
+
+#endif
+
+#endif // __TRACE_H__