src/policy_manager/policy_manager.cpp

   1 /*
   2  * Copyright (c) 2018 TOYOTA MOTOR CORPORATION
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <fstream>
  19 #include <sstream>
  20 #include <istream>
  21 #include <json-c/json.h>
  22 #include "policy_manager.hpp"
  23 #include "hmi-debug.h"
  24
  25 namespace stm {
  26 extern "C" {
  27 #include "dummy_stm.h"
  28 }
  29 } // namespace stm
  30
  31
  32 PolicyManager::PolicyManager() :
  33   eventname2no_(),
  34   categoryname2no_(),
  35   areaname2no_(),
  36   role2category_(),
  37   category2role_(),
  38   role2defaultarea_()
  39 {
  40     HMI_DEBUG("wm:pm", "Call");
  41 }
  42
  43 int PolicyManager::initialize() {
  44     HMI_DEBUG("wm:pm", "Call");
  45
  46     int ret = 0;
  47
  48     // Create convert map
  49     for (unsigned int i=0; i<STM_NUM_EVT; i++) {
  50         HMI_DEBUG("wm:pm", "event name:%s no:%d", stm::gStmEventName[i], stm::gStmEventNo[i]);
  51         this->eventname2no_[stm::gStmEventName[i]] = stm::gStmEventNo[i];
  52     }
  53
  54     for (unsigned int i=0; i<STM_NUM_CTG; i++) {
  55         HMI_DEBUG("wm:pm", "category name:%s no:%d", stm::gStmCategoryName[i], stm::gStmCategoryNo[i]);
  56         this->categoryname2no_[stm::gStmCategoryName[i]] = stm::gStmCategoryNo[i];
  57     }
  58
  59     for (unsigned int i=0; i<STM_NUM_ARA; i++) {
  60         HMI_DEBUG("wm:pm", "area name:%s no:%d", stm::gStmAreaName[i], stm::gStmAreaNo[i]);
  61         this->areaname2no_[stm::gStmAreaName[i]] = stm::gStmAreaNo[i];
  62     }
  63
  64     // Load role.db
  65     ret = loadRoleDb();
  66     if (0 > ret) {
  67         HMI_ERROR("wm:pm", "Load role.db Error!!");
  68         return ret;
  69     }
  70
  71     // Initialize StateTransitioner
  72     stm::stmInitialize();
  73
  74     return ret;
  75 }
  76
  77 int PolicyManager::checkPolicy(json_object* json_in, json_object** json_out) {
  78     HMI_DEBUG("wm:pm", "Call");
  79
  80     // Check arguments
  81     if ((nullptr == json_in) || (nullptr == json_out)) {
  82         HMI_ERROR("wm:pm", "Argument is NULL!!");
  83         return -1;
  84     }
  85
  86     // Get event from json_object
  87     const char* event = this->getStringFromJson(json_in, "event");
  88     int event_no = 0;
  89     if (nullptr != event) {
  90         // Convert name to number
  91         event_no = this->eventname2no_[event];
  92         HMI_DEBUG("wm:pm", "event(%s:%d)", event, event_no);
  93     }
  94
  95     // Get role from json_object
  96     const char* role = this->getStringFromJson(json_in, "role");
  97     int category_no = 0;
  98     if (nullptr != role) {
  99         HMI_DEBUG("wm:pm", "role(%s)", role);
 100
 101         // Convert role to category
 102         const char* category = this->role2category_[role].c_str();
 103         if (0 == strcmp("", category)) {
 104             HMI_ERROR("wm:pm", "Error!!");
 105             return -1;
 106         }
 107         HMI_DEBUG("wm:pm", "category(%s)", category);
 108
 109         // Convert name to number
 110         category_no = categoryname2no_[category];
 111         HMI_DEBUG("wm:pm", "role(%s), category(%s:%d)", role, category, category_no);
 112     }
 113
 114     // Get areat from json_object
 115     const char* area = this->getStringFromJson(json_in, "area");
 116     int area_no = 0;
 117     if (nullptr != area) {
 118         // Convert name to number
 119         area_no = areaname2no_[area];
 120         HMI_DEBUG("wm:pm", "area(%s:%d)", area, area_no);
 121     }
 122
 123     HMI_DEBUG("wm:pm", "set event:0x%x", (event_no | category_no | area_no));
 124
 125     // Transition state
 126     stm::stm_state_t crr_state;
 127     int ret = stm::stmTransitionState((event_no | category_no | area_no), &crr_state);
 128     if (0 > ret) {
 129         HMI_ERROR("wm:pm", "Error!!");
 130         return -1;
 131     }
 132
 133     // Create result
 134     // {
 135     //     "parking_brake": {
 136     //         "is_changed": <bool>,
 137     //         "state": <const char*>
 138     //     },
 139     HMI_DEBUG("wm", "parking brake state (is_changed:%d state:%d:%s)",
 140               crr_state.parking_brake.is_changed,
 141               crr_state.parking_brake.state,
 142               stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state]);
 143     this->addStateToJson("parking_brake",
 144                          crr_state.parking_brake.is_changed,
 145                          stm::gStmParkingBrakeStateNo2Name[crr_state.parking_brake.state],
 146                          json_out);
 147
 148     //     "accel_pedal": {
 149     //         "is_changed": <bool>,
 150     //         "state": <const char*>
 151     //     },
 152     HMI_DEBUG("wm", "accelerator pedal state (is_changed:%d state:%d:%s)",
 153               crr_state.accel_pedal.is_changed,
 154               crr_state.accel_pedal.state,
 155               stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state]);
 156     this->addStateToJson("accel_pedal",
 157                          crr_state.accel_pedal.is_changed,
 158                          stm::gStmAccelPedalStateNo2Name[crr_state.accel_pedal.state],
 159                          json_out);
 160
 161     //     "car": {
 162     //         "is_changed": <bool>,
 163     //         "state": <const char*>
 164     //     },
 165     HMI_DEBUG("wm", "car state (is_changed:%d state:%d:%s)",
 166               crr_state.car.is_changed,
 167               crr_state.car.state,
 168               stm::gStmCarStateNo2Name[crr_state.car.state]);
 169     this->addStateToJson("car",
 170                          crr_state.car.is_changed,
 171                          stm::gStmCarStateNo2Name[crr_state.car.state],
 172                          json_out);
 173
 174     //     "lamp": {
 175     //         "is_changed": <bool>,
 176     //         "state": <const char*>
 177     //     },
 178     HMI_DEBUG("wm", "lamp state (is_changed:%d state:%d:%s)",
 179               crr_state.lamp.is_changed,
 180               crr_state.lamp.state,
 181               stm::gStmLampStateNo2Name[crr_state.lamp.state]);
 182     this->addStateToJson("lamp",
 183                          crr_state.lamp.is_changed,
 184                          stm::gStmLampStateNo2Name[crr_state.lamp.state],
 185                          json_out);
 186
 187     //     "layers": [
 188     json_object* json_layer = json_object_new_array();
 189     json_object* json_tmp;
 190
 191     //         {
 192     //             "homescreen": {
 193     //                 "is_changed": <bool>,
 194     //                 "state": <const char*>
 195     //             }
 196     //         },
 197     //     ]
 198     // }
 199     HMI_DEBUG("wm", "homescreen state (is_changed:%d state:%d:%s)",
 200               crr_state.layer.homescreen.is_changed,
 201               crr_state.layer.homescreen.state,
 202               stm::gStmLayoutNo2Name[crr_state.layer.homescreen.state]);
 203     json_tmp = json_object_new_object();
 204     this->addStateToJson("homescreen",
 205                          crr_state.layer.homescreen.is_changed,
 206                          stm::gStmLayoutNo2Name[crr_state.layer.homescreen.state],
 207                          &json_tmp);
 208     json_object_array_add(json_layer, json_tmp);
 209
 210     //         {
 211     //             "apps": {
 212     //                 "is_changed": <bool>,
 213     //                 "state": <const char*>
 214     //             }
 215     //         },
 216     HMI_DEBUG("wm", "apps state (is_changed:%d state:%d:%s)",
 217               crr_state.layer.apps.is_changed,
 218               crr_state.layer.apps.state,
 219               stm::gStmLayoutNo2Name[crr_state.layer.apps.state]);
 220     json_tmp = json_object_new_object();
 221     this->addStateToJson("apps",
 222                          crr_state.layer.apps.is_changed,
 223                          stm::gStmLayoutNo2Name[crr_state.layer.apps.state],
 224                          &json_tmp);
 225     json_object_array_add(json_layer, json_tmp);
 226
 227     //         {
 228     //             "restriction": {
 229     //                 "is_changed": <bool>,
 230     //                 "state": <const char*>
 231     //             }
 232     //         },
 233     HMI_DEBUG("wm", "restriction state (is_changed:%d state:%d:%s)",
 234               crr_state.layer.restriction.is_changed,
 235               crr_state.layer.restriction.state,
 236               stm::gStmLayoutNo2Name[crr_state.layer.restriction.state]);
 237     json_tmp = json_object_new_object();
 238     this->addStateToJson("restriction",
 239                          crr_state.layer.restriction.is_changed,
 240                          stm::gStmLayoutNo2Name[crr_state.layer.restriction.state],
 241                          &json_tmp);
 242     json_object_array_add(json_layer, json_tmp);
 243
 244     //         {
 245     //             "on_screen": {
 246     //                 "is_changed": <bool>,
 247     //                 "state": <const char*>
 248     //             }
 249     //         },
 250     HMI_DEBUG("wm", "on_screen state (is_changed:%d state:%d:%s)",
 251               crr_state.layer.on_screen.is_changed,
 252               crr_state.layer.on_screen.state,
 253               stm::gStmLayoutNo2Name[crr_state.layer.on_screen.state]);
 254     json_tmp = json_object_new_object();
 255     this->addStateToJson("on_screen",
 256                          crr_state.layer.on_screen.is_changed,
 257                          stm::gStmLayoutNo2Name[crr_state.layer.on_screen.state],
 258                          &json_tmp);
 259     json_object_array_add(json_layer, json_tmp);
 260
 261     // Add json array of layer
 262     json_object_object_add(*json_out, "layers", json_layer);
 263
 264     return 0;
 265 }
 266
 267 std::string PolicyManager::roleToCategory(const char* role) {
 268     return this->role2category_[role];
 269 }
 270
 271 extern const char* kDefaultRoleDb;
 272 int PolicyManager::loadRoleDb() {
 273     HMI_DEBUG("wm:pm", "Call");
 274
 275     std::string file_name;
 276
 277     // Get afm application installed dir
 278     char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR");
 279     HMI_DEBUG("wm:pm", "afm_app_install_dir:%s", afm_app_install_dir);
 280
 281     if (!afm_app_install_dir) {
 282         HMI_ERROR("wm:pm", "AFM_APP_INSTALL_DIR is not defined");
 283     }
 284     else {
 285         file_name = std::string(afm_app_install_dir) + std::string("/etc/role.db");
 286     }
 287
 288     // Load role.db
 289     json_object* json_obj;
 290     int ret = this->inputJsonFilie(file_name.c_str(), &json_obj);
 291     if (0 > ret) {
 292         HMI_ERROR("wm:pm", "Could not open role.db, so use default role information");
 293         json_obj = json_tokener_parse(kDefaultRoleDb);
 294     }
 295     HMI_DEBUG("wm:pm", "json_obj dump:%s", json_object_get_string(json_obj));
 296
 297     json_object* json_roles;
 298     if (!json_object_object_get_ex(json_obj, "roles", &json_roles)) {
 299         HMI_ERROR("wm:pm", "Parse Error!!");
 300         return -1;
 301     }
 302
 303     int len = json_object_array_length(json_roles);
 304     HMI_DEBUG("wm:pm", "json_cfg len:%d", len);
 305     HMI_DEBUG("wm:pm", "json_cfg dump:%s", json_object_get_string(json_roles));
 306
 307     json_object* json_tmp;
 308     const char* category;
 309     const char* roles;
 310     const char* areas;
 311     for (int i=0; i<len; i++) {
 312         json_tmp = json_object_array_get_idx(json_roles, i);
 313
 314         category = this->getStringFromJson(json_tmp, "category");
 315         roles =  this->getStringFromJson(json_tmp, "role");
 316         areas =  this->getStringFromJson(json_tmp, "area");
 317
 318         if ((nullptr == category) || (nullptr == roles) || (nullptr == areas)) {
 319             HMI_ERROR("wm:pm", "Parse Error!!");
 320             return -1;
 321         }
 322
 323         // Parse roles by '|'
 324         std::vector<std::string> vct_roles;
 325         vct_roles = this->parseString(std::string(roles), '|');
 326
 327         // Parse areas by '|'
 328         std::vector<std::string> vct_areas;
 329         vct_areas = this->parseString(std::string(areas), '|');
 330
 331         // Set role, category, default area
 332         for (auto itr = vct_roles.begin(); itr != vct_roles.end(); ++itr) {
 333             // Delete space from role and area name
 334             std::string role = this->deleteSpace(*itr);
 335             std::string area = this->deleteSpace(vct_areas[0]);
 336
 337             this->role2category_[role] = std::string(category);
 338             this->role2defaultarea_[role] = area;
 339         }
 340
 341         this->category2role_[std::string(category)] = std::string(roles);
 342     }
 343
 344     // Check
 345     HMI_DEBUG("wm:pm", "Check role2category_");
 346     for (auto& x:this->role2category_){
 347         HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), x.second.c_str());
 348     }
 349
 350     HMI_DEBUG("wm:pm", "Check role2defaultarea_");
 351     for (auto& x:this->role2defaultarea_){
 352         HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), x.second.c_str());
 353     }
 354
 355     HMI_DEBUG("wm:pm", "Check category2role_");
 356     for (auto& x:this->category2role_){
 357         HMI_DEBUG("wm:pm", "key:%s, val:%s", x.first.c_str(), x.second.c_str());
 358     }
 359
 360     return 0;
 361 }
 362
 363 // TODO:
 364 // This function will be removed because json_helper has same function.
 365 // json_helper should be library.
 366 const char* PolicyManager::getStringFromJson(json_object* obj, const char* key) {
 367     if ((nullptr == obj) || (nullptr == key)) {
 368         HMI_ERROR("wm:pm", "Argument is nullptr!!!");
 369         return nullptr;
 370     }
 371
 372     json_object* tmp;
 373     if (!json_object_object_get_ex(obj, key, &tmp)) {
 374         HMI_DEBUG("wm:pm", "Not found key \"%s\"", key);
 375         return nullptr;
 376     }
 377
 378     return json_object_get_string(tmp);
 379 }
 380
 381 // TODO:
 382 // This function will be removed because json_helper has same function.
 383 // json_helper should be library.
 384 int PolicyManager::inputJsonFilie(const char* file, json_object** obj) {
 385     const int input_size = 128;
 386     int ret = -1;
 387
 388     if ((nullptr == file) || (nullptr == obj)) {
 389         HMI_ERROR("wm:jh", "Argument is nullptr!!!");
 390         return ret;
 391     }
 392
 393     HMI_DEBUG("wm:jh", "Input file: %s", file);
 394
 395     // Open json file
 396     FILE *fp = fopen(file, "rb");
 397     if (nullptr == fp) {
 398         HMI_ERROR("wm:jh", "Could not open file");
 399         return ret;
 400     }
 401
 402     // Parse file data
 403     struct json_tokener *tokener = json_tokener_new();
 404     enum json_tokener_error json_error;
 405     char buffer[input_size];
 406     int block_cnt = 1;
 407     while (1) {
 408         size_t len = fread(buffer, sizeof(char), input_size, fp);
 409         *obj = json_tokener_parse_ex(tokener, buffer, len);
 410         if (nullptr != *obj) {
 411             HMI_DEBUG("wm:jh", "File input is success");
 412             ret = 0;
 413             break;
 414         }
 415
 416         json_error = json_tokener_get_error(tokener);
 417         if ((json_tokener_continue != json_error)
 418             || (input_size > len)) {
 419             HMI_ERROR("wm:jh", "Failed to parse file (byte:%d err:%s)",
 420                       (input_size * block_cnt), json_tokener_error_desc(json_error));
 421             HMI_ERROR("wm:jh", "\n%s", buffer);
 422             *obj = nullptr;
 423             break;
 424         }
 425         block_cnt++;
 426     }
 427
 428     // Close json file
 429     fclose(fp);
 430
 431     // Free json_tokener
 432     json_tokener_free(tokener);
 433
 434     return ret;
 435 }
 436
 437 void PolicyManager::addStateToJson(
 438   const char* key, int is_changed, const char* state, json_object** json_out) {
 439     if ((nullptr == key) || (nullptr == state) || (nullptr == json_out)) {
 440         HMI_ERROR("wm:pm", "Argument is nullptr!!!");
 441         return;
 442     }
 443
 444     json_object* json_obj = json_object_new_object();
 445     json_object_object_add(json_obj, "is_changed", json_object_new_boolean(is_changed));
 446     if (is_changed) {
 447         HMI_DEBUG("wm:pm", "%s: state changed (%s)", key, state);
 448         json_object_object_add(json_obj, "state", json_object_new_string(state));
 449     }
 450     json_object_object_add(*json_out, key, json_obj);
 451 }
 452
 453 std::vector<std::string> PolicyManager::parseString(std::string str, char delimiter) {
 454     // Parse string by delimiter
 455     std::vector<std::string> vct;
 456     std::stringstream ss{str};
 457     std::string buf;
 458     while (std::getline(ss, buf, delimiter)) {
 459       if (!buf.empty()) {
 460         vct.push_back(buf);
 461       }
 462     }
 463     return vct;
 464 }
 465
 466 std::string PolicyManager::deleteSpace(std::string str) {
 467     std::string ret = str;
 468     size_t pos;
 469     while ((pos = ret.find_first_of(" ")) != std::string::npos) {
 470       ret.erase(pos, 1);
 471     }
 472     return ret;
 473 }
 474
 475 const char* kDefaultRoleDb = "{ \
 476     \"roles\":[ \
 477     { \
 478         \"category\": \"homescreen\", \
 479         \"role\": \"homescreen\", \
 480         \"area\": \"full\", \
 481     }, \
 482     { \
 483         \"category\": \"map\", \
 484         \"role\": \"map\", \
 485         \"area\": \"full | normal | split.main\", \
 486     }, \
 487     { \
 488         \"category\": \"general\", \
 489         \"role\": \"poi | music | video | browser | sdl | settings | mixer | radio | hvac | dashboard | debug\", \
 490         \"area\": \"normal\", \
 491     }, \
 492     { \
 493         \"category\": \"phone\", \
 494         \"role\": \"phone\", \
 495         \"area\": \"normal\", \
 496     }, \
 497     { \
 498         \"category\": \"splitable\", \
 499         \"role\": \"splitable1 | splitable2\", \
 500         \"area\": \"normal | split.main | split.sub\", \
 501     }, \
 502     { \
 503         \"category\": \"popup\", \
 504         \"role\": \"popup\", \
 505         \"area\": \"on_screen\", \
 506     }, \
 507     { \
 508         \"category\": \"system_alert\", \
 509         \"role\": \"system_alert\", \
 510         \"area\": \"on_screen\", \
 511     }, \
 512     { \
 513         \"category\": \"tbt\", \
 514         \"role\": \"tbt\", \
 515         \"area\": \"hud\", \
 516     } \
 517     ] \
 518 }";