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