src/hs-config.cpp

   1 /*
   2  * Copyright (c) 2019 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 "hs-config.h"
  19
  20 const std::array<std::string, 3> HS_Config::keys_recover_type = {   // based on hs-conf.json
  21     "hs-apps",
  22     "default-lastmode",
  23     "normal-apps"
  24 };
  25 const std::string HS_Config::lastmode_json = "lastmode.json";
  26 const std::string HS_Config::key_appid = "appid";
  27 const std::string HS_Config::key_visibility = "visibility";
  28 std::string HS_Config::root_dir = "";
  29
  30 /**
  31  * read configuration file to memory
  32  *
  33  * #### Parameters
  34  *  - Nothing
  35  *
  36  * #### Return
  37  * None
  38  *
  39  */
  40 int HS_Config::readConfig(void)
  41 {
  42     root_dir = std::string(getenv("AFM_APP_INSTALL_DIR"));
  43     auto path = root_dir + "/etc/" + hs_conf_json;
  44     if(readJsonFile(path.c_str(), &m_hs_conf) < 0) {
  45         AFB_ERROR("read %s failed.", hs_conf_json.c_str());
  46         return -1;
  47     }
  48
  49     path = root_dir + "/etc/" + lastmode_json;
  50     if(readJsonFile(path.c_str(), &m_lastmode) < 0) {
  51         AFB_ERROR("read %s failed.", lastmode_json.c_str());
  52         m_lastmode = nullptr;
  53     }
  54
  55     return parseConfig();
  56 }
  57
  58 /**
  59  * parse configuration file contents
  60  *
  61  * #### Parameters
  62  *  - Nothing
  63  *
  64  * #### Return
  65  * 0 : success
  66  * 1 : fail
  67  *
  68  */
  69 int HS_Config::parseConfig(void)
  70 {
  71     struct json_object *handshake_obj, *times_obj, *sleep_obj;
  72     if(json_object_object_get_ex(m_hs_conf, key_handshake.c_str(), &handshake_obj)
  73     && json_object_object_get_ex(handshake_obj, key_times.c_str(), &times_obj)
  74     && json_object_object_get_ex(handshake_obj, key_sleep.c_str(), &sleep_obj)) {
  75         m_handshake_info.times = json_object_get_int(times_obj);
  76         m_handshake_info.sleep = json_object_get_int(sleep_obj);
  77     }
  78     else {
  79         AFB_WARNING("get handshake info error, use default value.");
  80     }
  81
  82     struct json_object *recover_obj;
  83     if(json_object_object_get_ex(m_hs_conf, key_recover.c_str(), &recover_obj)) {
  84         for(auto &m : keys_recover_type) {
  85             struct json_object *obj;
  86             if(json_object_object_get_ex(recover_obj, m.c_str(), &obj)) {
  87                 if(json_object_get_type(obj) != json_type_array ) {
  88                     continue;
  89                 }
  90                 m_recover_map[m] = std::move(getRecoverAppInfo(obj));
  91             }
  92         }
  93
  94         if(m_recover_map.empty()) {
  95             AFB_ERROR("get homescreen recover list failed.");
  96             return -1;
  97         }
  98     }
  99     else {
 100         AFB_ERROR("get homescreen recover object failed.");
 101         return -1;
 102     }
 103
 104     if(json_object_get_type(m_lastmode) == json_type_array ) {
 105         struct std::vector<recover_app_info> v_lastmode = std::move(getRecoverAppInfo(m_lastmode));
 106         if(!v_lastmode.empty()) {   // got saving lastmode isn't null, instead of default lastmode
 107             m_recover_map[keys_recover_type[1]] = std::move(v_lastmode);
 108         }
 109     }
 110
 111     return 0;
 112 }
 113
 114 /**
 115  * get recover application information
 116  * appid, visibility
 117  *
 118  * #### Parameters
 119  *  - obj : application information
 120  *
 121  * #### Return
 122  * recover_app_info vector
 123  *
 124  */
 125 std::vector<struct recover_app_info> HS_Config::getRecoverAppInfo(struct json_object *obj)
 126 {
 127     int array_len = json_object_array_length(obj);
 128     std::vector<struct recover_app_info> v_app_info;
 129     for (int i = 0; i < array_len; ++i) {
 130         struct json_object *info_obj = json_object_array_get_idx(obj, i);
 131         struct recover_app_info info;
 132         struct json_object *value_obj;
 133         if(json_object_object_get_ex(info_obj, key_appid.c_str(), &value_obj)) {
 134             info.appid = json_object_get_string(value_obj);
 135         }
 136         else {
 137             AFB_ERROR("recover infomation doesn't include appid.");
 138             v_app_info.clear();
 139             return v_app_info;
 140         }
 141         if(json_object_object_get_ex(info_obj, key_visibility.c_str(), &value_obj)) {
 142             std::string visibility = json_object_get_string(value_obj);
 143             info.visibility = (visibility == "visible") ? true:false;
 144         }
 145         else {
 146             info.visibility = false;
 147         }
 148         v_app_info.push_back(info);
 149     }
 150
 151     return v_app_info;
 152 }