src/wm_layer.cpp

   1 /*
   2  * Copyright (c) 2017 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 #include <regex>
  18 #include <ilm/ilm_control.h>
  19 #include <stdlib.h>
  20 #include "wm_client.hpp"
  21 #include "wm_layer.hpp"
  22 #include "json_helper.hpp"
  23 #include "util.hpp"
  24
  25 using std::string;
  26 using std::vector;
  27 using std::unordered_map;
  28
  29 #define BG_LAYER_NAME "BackGroundLayer"
  30
  31 namespace wm
  32 {
  33
  34 LayerState::LayerState()
  35     :  render_order(),
  36        area2appid()
  37 {}
  38
  39
  40 void LayerState::attachIdToArea(const string& area, const WMClient& client)
  41 {
  42     this->area2appid[area] = client.appID();
  43     this->render_order.push_back(client.layerID());
  44 }
  45
  46 const unordered_map<string, string> LayerState::popCurrentState()
  47 {
  48     unordered_map<string, string> tmp = this->area2appid;
  49     this->area2appid.clear();
  50     this->render_order.clear();
  51     return tmp;
  52 }
  53
  54 const unordered_map<string, string> LayerState::getCurrentState()
  55 {
  56     return this->area2appid;
  57 }
  58
  59 const vector<unsigned> LayerState::getIviIdList()
  60 {
  61     return this->render_order;
  62 }
  63
  64 void LayerState::addLayer(unsigned layer)
  65 {
  66     auto result = std::find(this->render_order.begin(), this->render_order.end(), layer);
  67     if(result == this->render_order.end())
  68         this->render_order.push_back(layer);
  69 }
  70
  71 void LayerState::removeLayer(unsigned layer)
  72 {
  73     auto fwd_itr = std::remove_if(
  74         this->render_order.begin(), this->render_order.end(),
  75         [layer](unsigned elm) {
  76             if(elm == layer)
  77                 HMI_DEBUG("remove layer %d", elm);
  78             return elm == layer;
  79         }
  80     );
  81     this->render_order.erase(fwd_itr, this->render_order.end());
  82 }
  83
  84 void LayerState::attachAppToArea(const string& app, const string& area)
  85 {
  86     this->area2appid[area] = app;
  87 }
  88
  89 void LayerState::dump()
  90 {
  91     std::string ids, apps;
  92     for(const auto& ro : this->render_order)
  93     {
  94         ids += std::to_string(ro);
  95         ids += ",";
  96     }
  97     for(const auto& area : this->area2appid)
  98     {
  99         apps += area.first;
 100         apps += ":";
 101         apps += area.second;
 102         apps += ",";
 103     }
 104     DUMP("    render order : %s", ids.c_str());
 105     DUMP("    area, app    : %s", apps.c_str());
 106 }
 107
 108 WMLayer::WMLayer(json_object* j, unsigned wm_layer_id) : tmp_state(), state(), wm_layer_id(wm_layer_id)
 109 {
 110     this->name = jh::getStringFromJson(j, "name");
 111     this->role_list = jh::getStringFromJson(j, "role");
 112     this->id_begin = static_cast<unsigned>(jh::getIntFromJson(j, "id_range_begin"));
 113     this->id_end = static_cast<unsigned>(jh::getIntFromJson(j, "id_range_end"));
 114
 115     if (name.empty())
 116     {
 117         HMI_ERROR("Parse Error!!");
 118         exit(1);
 119     }
 120     if(this->id_begin > this->id_end)
 121     {
 122         HMI_ERROR("INVALID");
 123         exit(1);
 124     }
 125 }
 126
 127 unsigned WMLayer::getNewLayerID(const string& role)
 128 {
 129     unsigned ret = 0;
 130     if(this->name == BG_LAYER_NAME)
 131         return ret;
 132
 133     // generate new layer id;
 134     if(this->hasRole(role))
 135     {
 136         if(this->id_list.size() == 0)
 137         {
 138             ret = this->idBegin();
 139             this->id_list.push_back(ret);
 140         }
 141         else
 142         {
 143             ret = this->id_list.back() + 1;
 144         }
 145         HMI_INFO("Generate new id: %d", ret);
 146     }
 147     else
 148     {
 149         return ret;
 150     }
 151
 152     size_t count = std::count(id_list.begin(), id_list.end(), ret);
 153     if( (ret > this->idEnd()) || (count > 1))
 154     {
 155         HMI_NOTICE("id %d is not available then generate new id", ret);
 156         ret = 0; // reset
 157         for(unsigned i = this->idBegin(); i < this->idEnd(); i++)
 158         {
 159             auto ret_found = std::find(id_list.begin(), id_list.end(), i);
 160             if(ret_found == id_list.cend())
 161             {
 162                 HMI_INFO("set new id: %d", i);
 163                 ret = i;
 164                 break;
 165             }
 166         }
 167     }
 168
 169     if(ret != 0)
 170     {
 171         id_list.push_back(ret);
 172     }
 173     else
 174     {
 175         HMI_ERROR("failed to get New ID");
 176     }
 177     return ret;
 178 }
 179
 180 const string& WMLayer::layerName()
 181 {
 182     return this->name;
 183 }
 184
 185 WMError WMLayer::setLayerState(const LayerState& l)
 186 {
 187     this->tmp_state = l;
 188     return WMError::SUCCESS;
 189 }
 190
 191 void WMLayer::addLayerToState(unsigned layer)
 192 {
 193     this->tmp_state.addLayer(layer);
 194 }
 195
 196 void WMLayer::removeLayerFromState(unsigned layer)
 197 {
 198     this->tmp_state.removeLayer(layer);
 199 }
 200
 201 void WMLayer::attachAppToArea(const string& app, const string& area)
 202 {
 203     this->tmp_state.attachAppToArea(app, area);
 204 }
 205
 206 void WMLayer::appendArea(const string& area)
 207 {
 208     this->area_list.push_back(area);
 209 }
 210
 211 void WMLayer::appTerminated(unsigned id)
 212 {
 213     auto fwd_itr = std::remove_if(this->id_list.begin(), this->id_list.end(),
 214         [id](unsigned elm) {
 215             return elm == id;
 216         });
 217     this->id_list.erase(fwd_itr, this->id_list.end());
 218     this->tmp_state.removeLayer(id);
 219     this->state.removeLayer(id);
 220     ilm_layerRemove(id);
 221 }
 222
 223 bool WMLayer::hasLayerID(unsigned id)
 224 {
 225     bool ret = (id >= this->idBegin() && id <= this->idEnd());
 226     if(!ret)
 227         return ret;
 228     auto itr = std::find(this->id_list.begin(), this->id_list.end(), id);
 229     return (itr != this->id_list.end()) ? true : false;
 230 }
 231
 232 bool WMLayer::hasRole(const string& role)
 233 {
 234     auto re = std::regex(this->role_list);
 235     if (std::regex_match(role, re))
 236     {
 237         HMI_DEBUG("role %s matches layer %s", role.c_str(), this->name.c_str());
 238         return true;
 239     }
 240     return false;
 241 }
 242
 243 void WMLayer::update()
 244 {
 245     this->state = this->tmp_state;
 246 }
 247
 248 void WMLayer::undo()
 249 {
 250     this->tmp_state = this->state;
 251 }
 252
 253 void WMLayer::dump()
 254 {
 255     DUMP("===== wm layer status =====");
 256     DUMP("Layer :%s", this->name.c_str());
 257     this->tmp_state.dump();
 258     this->state.dump();
 259     DUMP("===== wm layer status end =====");
 260
 261 }
 262
 263 /* void WMLayer::undo()
 264 {
 265     this->tmp_state = this->state;
 266 }
 267  */
 268 } // namespace wm