src/api.cpp

   1 // Copyright 2017 AW SOFTWARE CO.,LTD
   2 // Copyright 2017 AISIN AW CO.,LTD
   3
   4 #include <string.h>
   5
   6 #include "binder_reply.h"
   7 #include "genivi_request.h"
   8 #include "analyze_request.h"
   9 #include "genivi/genivi-navicore-constants.h"
  10
  11 #define AFB_BINDING_VERSION 2
  12
  13 extern "C" {
  14         #include <afb/afb-binding.h>
  15 }
  16
  17 /**
  18  *  Variable declaration
  19  */
  20 GeniviRequest* geniviRequest;   // Send request to Genivi
  21 BinderReply* binderReply;       // Convert Genivi response result to json format
  22 AnalyzeRequest* analyzeRequest; // Analyze BinderClient's request and create arguments to pass to GeniviAPI
  23
  24 /**
  25  *  @brief navicore_getposition request callback
  26  *  @param[in] req Request from client
  27  */
  28 void OnRequestNavicoreGetPosition(afb_req req)
  29 {
  30         AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
  31         AFB_REQ_DEBUG(req, "request navicore_getposition");
  32
  33         // Request of Json format request
  34         json_object* req_json = afb_req_json(req);
  35         const char* req_json_str = json_object_to_json_string(req_json);
  36         AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
  37
  38         // Request analysis and create arguments to pass to Genivi
  39         std::vector< int32_t > Params;
  40         if( !analyzeRequest->CreateParamsGetPosition( req_json_str, Params ))
  41         {
  42                 afb_req_fail(req, "failed", "navicore_getposition Bad Request");
  43                 return;
  44         }
  45
  46         // GENIVI API call
  47         std::map< int32_t, double > posList = geniviRequest->NavicoreGetPosition( Params );
  48
  49         // Convert to json style response
  50         APIResponse response = binderReply->ReplyNavicoreGetPosition( posList );
  51
  52         // On success
  53         if(response.isSuccess)
  54         {
  55                 AFB_REQ_NOTICE(req, "res_json_str = %s", json_object_to_json_string(response.json_data));
  56                 // Return success to BinderClient
  57                 afb_req_success(req, response.json_data, "navicore_getposition");
  58         }
  59         else
  60         {
  61                 AFB_REQ_ERROR(req, "%s - %s:%d", response.errMessage.c_str(), __FILE__, __LINE__);
  62                 afb_req_fail(req, "failed", "navicore_getposition Bad Request");
  63
  64                 // Json object release
  65                 json_object_put(response.json_data);
  66         }
  67
  68         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
  69 }
  70
  71
  72 /**
  73  *  @brief navicore_getallroutes request callback
  74  *  @param[in] req Request from client
  75  */
  76 void OnRequestNavicoreGetAllRoutes(afb_req req)
  77 {
  78         AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
  79         AFB_REQ_DEBUG(req, "request navicore_getallroutes");
  80
  81         // No request information in json format
  82         AFB_REQ_NOTICE(req, "req_json_str = none");
  83
  84         // GENEVI API call
  85         std::vector< uint32_t > allRoutes = geniviRequest->NavicoreGetAllRoutes();
  86
  87         // Convert to json style response
  88         APIResponse response = binderReply->ReplyNavicoreGetAllRoutes( allRoutes );
  89
  90         // On success
  91         if(response.isSuccess)
  92         {
  93                 AFB_REQ_NOTICE(req, "res_json_str = %s", json_object_to_json_string(response.json_data));
  94                 // Return success to BinderClient
  95                 afb_req_success(req, response.json_data, "navicore_getallroutes");
  96         }
  97         else
  98         {
  99                 AFB_REQ_ERROR(req, "%s - %s:%d", response.errMessage.c_str(), __FILE__, __LINE__);
 100                 afb_req_fail(req, "failed", "navicore_getallroutes Bad Request");
 101
 102                 // json object release
 103                 json_object_put(response.json_data);
 104         }
 105
 106         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
 107 }
 108
 109
 110 /**
 111  *  @brief navicore_createroute request callback
 112  *  @param[in] req Request from client
 113  */
 114 void OnRequestNavicoreCreateRoute(afb_req req)
 115 {
 116         AFB_REQ_NOTICE(req, "--> Start %s ", __func__);
 117         AFB_REQ_DEBUG(req, "request navicore_createroute");
 118
 119         // Request of json format request
 120         json_object* req_json = afb_req_json(req);
 121         const char* req_json_str = json_object_to_json_string(req_json);
 122         AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
 123
 124         // Request analysis and create arguments to pass to Genivi
 125         uint32_t sessionHdl = 0;
 126         if( !analyzeRequest->CreateParamsCreateRoute( req_json_str, sessionHdl ))
 127         {
 128                 afb_req_fail(req, "failed", "navicore_createroute Bad Request");
 129                 return;
 130         }
 131
 132         // GENEVI API call
 133         uint32_t routeHdl = geniviRequest->NavicoreCreateRoute( sessionHdl );
 134
 135         // Convert to json style response
 136         APIResponse response = binderReply->ReplyNavicoreCreateRoute( routeHdl );
 137
 138         // On success
 139         if(response.isSuccess)
 140         {
 141                 AFB_REQ_NOTICE(req, "res_json_str = %s", json_object_to_json_string(response.json_data));
 142                 // Return success to BinderClient
 143                 afb_req_success(req, response.json_data, "navicore_createroute");
 144         }
 145         else
 146         {
 147                 AFB_REQ_ERROR(req, "%s - %s:%d", response.errMessage.c_str(), __FILE__, __LINE__);
 148                 afb_req_fail(req, "failed", "navicore_createroute Bad Request");
 149
 150                 // json object release
 151                 json_object_put(response.json_data);
 152         }
 153
 154         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
 155 }
 156
 157
 158 /**
 159  *  @brief navicore_pausesimulation request callback
 160  *  @param[in] req Request from client
 161  */
 162 void OnRequestNavicorePauseSimulation(afb_req req)
 163 {
 164         AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
 165         AFB_REQ_DEBUG(req, "request navicore_pausesimulation");
 166
 167         // Request of json format request
 168         json_object* req_json = afb_req_json(req);
 169         const char* req_json_str = json_object_to_json_string(req_json);
 170         AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
 171
 172         // Request analysis and create arguments to pass to Genivi
 173         uint32_t sessionHdl = 0;
 174         if( !analyzeRequest->CreateParamsPauseSimulation( req_json_str, sessionHdl ))
 175         {
 176                 afb_req_fail(req, "failed", "navicore_pausesimulation Bad Request");
 177                 return;
 178         }
 179
 180         // GENEVI API call
 181         geniviRequest->NavicorePauseSimulation( sessionHdl );
 182
 183         // No reply unnecessary API for conversion to json format response is unnecessary
 184         AFB_REQ_NOTICE(req, "res_json_str = none");
 185
 186         // Return success to BinderClient
 187         afb_req_success(req, NULL, "navicore_pausesimulation");
 188
 189         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
 190 }
 191
 192
 193 /**
 194  *  @brief navicore_setsimulationmode request callback
 195  *  @param[in] req Request from client
 196  */
 197 void OnRequestNavicoreSetSimulationMode(afb_req req)
 198 {
 199         AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
 200         AFB_REQ_DEBUG(req, "request navicore_setsimulationmode");
 201
 202         // Request of json format request
 203         json_object* req_json = afb_req_json(req);
 204         const char* req_json_str = json_object_to_json_string(req_json);
 205         AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
 206
 207         // Request analysis and create arguments to pass to Genivi
 208         uint32_t sessionHdl = 0;
 209         bool simuMode = false;
 210         if( !analyzeRequest->CreateParamsSetSimulationMode( req_json_str, sessionHdl, simuMode ))
 211         {
 212                 afb_req_fail(req, "failed", "navicore_setsimulationmode Bad Request");
 213                 return;
 214         }
 215
 216         // GENEVI API call
 217         geniviRequest->NavicoreSetSimulationMode( sessionHdl, simuMode );
 218
 219         // No reply unnecessary API for conversion to json format response is unnecessary
 220         AFB_REQ_NOTICE(req, "res_json_str = none");
 221
 222         // Return success to BinderClient
 223         afb_req_success(req, NULL, "navicore_setsimulationmode");
 224
 225         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
 226 }
 227
 228
 229 /**
 230  *  @brief navicore_cancelroutecalculation request callback
 231  *  @param[in] req Request from client
 232  */
 233 void OnRequestNavicoreCancelRouteCalculation(afb_req req)
 234 {
 235         AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
 236         AFB_REQ_DEBUG(req, "request navicore_cancelroutecalculation");
 237
 238         // Request of Json format request
 239         json_object* req_json = afb_req_json(req);
 240         const char* req_json_str = json_object_to_json_string(req_json);
 241         AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
 242
 243         // Request analysis and create arguments to pass to Genivi
 244         uint32_t sessionHdl = 0;
 245         uint32_t routeHdl = 0;
 246         if( !analyzeRequest->CreateParamsCancelRouteCalculation( req_json_str, sessionHdl, routeHdl ))
 247         {
 248                 afb_req_fail(req, "failed", "navicore_cancelroutecalculation Bad Request");
 249                 return;
 250         }
 251
 252         // GENEVI API call
 253         geniviRequest->NavicoreCancelRouteCalculation( sessionHdl, routeHdl );
 254
 255         // No reply unnecessary API for conversion to json format response is unnecessary
 256         AFB_REQ_NOTICE(req, "res_json_str = none");
 257
 258         // Return success to BinderClient
 259         afb_req_success(req, NULL, "navicore_cancelroutecalculation");
 260
 261         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
 262 }
 263
 264
 265 /**
 266  *  @brief navicore_setwaypoints request callback
 267  *  @param[in] req Request from client
 268  */
 269 void OnRequestNavicoreWaypoints(afb_req req)
 270 {
 271         AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
 272         AFB_REQ_DEBUG(req, "request navicore_setwaypoints");
 273
 274         // Request of Json format request
 275         json_object* req_json = afb_req_json(req);
 276         const char* req_json_str = json_object_to_json_string(req_json);
 277         AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
 278
 279         // Request analysis and create arguments to pass to Genivi
 280         uint32_t sessionHdl = 0;
 281         uint32_t routeHdl = 0;
 282         bool currentPos = false;
 283         std::vector<Waypoint> waypointsList;
 284         if( !analyzeRequest->CreateParamsSetWaypoints( req_json_str, sessionHdl, routeHdl, currentPos, waypointsList ))
 285         {
 286                 afb_req_fail(req, "failed", "navicore_setwaypoints Bad Request");
 287                 return;
 288         }
 289
 290         // GENEVI API call
 291         geniviRequest->NavicoreSetWaypoints( sessionHdl, routeHdl, currentPos, waypointsList );
 292
 293         // No reply unnecessary API for conversion to json format response is unnecessary
 294         AFB_REQ_NOTICE(req, "res_json_str = none");
 295
 296         // Return success to BinderClient
 297         afb_req_success(req, NULL, "navicore_setwaypoints");
 298
 299         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
 300 }
 301
 302
 303 /**
 304  *  @brief navicore_calculateroute request callback
 305  *  @param[in] req Request from client
 306  */
 307 void OnRequestNavicoreCalculateRoute(afb_req req)
 308 {
 309         AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
 310         AFB_REQ_DEBUG(req, "request navicore_calculateroute");
 311
 312         // Request of Json format request
 313         json_object* req_json = afb_req_json(req);
 314         const char* req_json_str = json_object_to_json_string(req_json);
 315         AFB_REQ_NOTICE(req, "req_json_str = %s", req_json_str);
 316
 317         // Request analysis and create arguments to pass to Genivi
 318         uint32_t sessionHdl = 0;
 319         uint32_t routeHdl = 0;
 320         if( !analyzeRequest->CreateParamsCalculateRoute( req_json_str, sessionHdl, routeHdl ))
 321         {
 322                 afb_req_fail(req, "failed", "navicore_calculateroute Bad Request");
 323                 return;
 324         }
 325
 326         // GENEVI API call
 327         geniviRequest->NavicoreCalculateRoute( sessionHdl, routeHdl );
 328
 329         // No reply unnecessary API for conversion to json format response is unnecessary
 330         AFB_REQ_NOTICE(req, "res_json_str = none");
 331
 332         // Return success to BinderClient
 333         afb_req_success(req, NULL, "navicore_calculateroute");
 334
 335         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
 336 }
 337
 338
 339 /**
 340  *  @brief navicore_getallsessions request callback
 341  *  @param[in] req Request from client
 342  */
 343 void OnRequestNavicoreGetAllSessions(afb_req req)
 344 {
 345         AFB_REQ_NOTICE(req, "--> Start %s()", __func__);
 346         AFB_REQ_DEBUG(req, "request navicore_getallsessions");
 347
 348         // No request information in Json format
 349         AFB_REQ_NOTICE(req, "req_json_str = none");
 350
 351         // GENEVI API call
 352         std::map<uint32_t, std::string> allSessions = geniviRequest->NavicoreGetAllSessions();
 353
 354         // Convert to json style response
 355         APIResponse response = binderReply->ReplyNavicoreGetAllSessions( allSessions );
 356
 357         // On success
 358         if(response.isSuccess)
 359         {
 360                 AFB_REQ_NOTICE(req, "res_json_str = %s", json_object_to_json_string(response.json_data));
 361                 // Return success to BinderClient
 362                 afb_req_success(req, response.json_data, "navicore_getallsessions");
 363         }
 364         else
 365         {
 366                 AFB_REQ_ERROR(req, "%s - %s:%d", response.errMessage.c_str(), __FILE__, __LINE__);
 367                 afb_req_fail(req, "failed", "navicore_getallsessions Bad Request");
 368
 369                 // json object release
 370                 json_object_put(response.json_data);
 371         }
 372
 373         AFB_REQ_NOTICE(req, "<-- End %s()", __func__);
 374 }
 375
 376
 377 /**
 378  *  @brief Callback called at service startup
 379  */
 380 int Init()
 381 {
 382         // Create instance
 383         geniviRequest   = new GeniviRequest();
 384         binderReply      = new BinderReply();
 385         analyzeRequest  = new AnalyzeRequest();
 386
 387         return 0;
 388 }
 389
 390 /**
 391  *  @brief API definition
 392  */
 393 const afb_verb_v2 verbs[] =
 394 {
 395          { verb : "navicore_getposition",                       callback : OnRequestNavicoreGetPosition },
 396          { verb : "navicore_getallroutes",                 callback : OnRequestNavicoreGetAllRoutes },
 397          { verb : "navicore_createroute",                       callback : OnRequestNavicoreCreateRoute },
 398          { verb : "navicore_pausesimulation",           callback : OnRequestNavicorePauseSimulation },
 399          { verb : "navicore_setsimulationmode",   callback : OnRequestNavicoreSetSimulationMode },
 400          { verb : "navicore_cancelroutecalculation", callback : OnRequestNavicoreCancelRouteCalculation },
 401          { verb : "navicore_setwaypoints",                 callback : OnRequestNavicoreWaypoints },
 402          { verb : "navicore_calculateroute",             callback : OnRequestNavicoreCalculateRoute },
 403          { verb : "navicore_getallsessions",             callback : OnRequestNavicoreGetAllSessions },
 404          { verb : NULL }
 405 };
 406
 407 /**
 408  *  @brief Service definition
 409  */
 410 const afb_binding_v2 afbBindingV2 =
 411 {
 412          "naviapi",
 413          "",
 414          "",
 415          verbs,
 416          NULL,
 417          Init
 418 };
 419