src/applist.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 #include <iostream>
  17 #include <algorithm>
  18 #include "applist.hpp"
  19 #include "../include/hmi-debug.h"
  20
  21 using std::shared_ptr;
  22 using std::string;
  23 using std::vector;
  24
  25 namespace wm
  26 {
  27
  28 AppList::AppList()
  29     : req_list(0),
  30       app2client(0),
  31       current_req(1)
  32 {
  33 }
  34
  35 void AppList::addClient(const string &appid, const string &role)
  36 {
  37     shared_ptr<WMClient> client = std::make_shared<WMClient>(appid, role);
  38     this->app2client[appid] = client;
  39     this->clientDump();
  40 }
  41
  42 void AppList::addClient(const std::string &appid, unsigned layer, unsigned surface, const std::string &role)
  43 {
  44     shared_ptr<WMClient> client = std::make_shared<WMClient>(appid, layer, surface, role);
  45     this->app2client[appid] = client;
  46     this->clientDump();
  47 }
  48
  49 void AppList::removeClient(const string &appid)
  50 {
  51     this->app2client.erase(appid);
  52 }
  53
  54 bool AppList::contains(const string &appid) const
  55 {
  56     auto result = this->app2client.find(appid);
  57     return (this->app2client.end() != result) ? true : false;
  58 }
  59
  60 void AppList::removeSurface(unsigned surface_id){
  61     // This function may be very slow
  62     bool ret = false;
  63     for (auto &x : this->app2client)
  64     {
  65         ret = x.second->removeSurfaceIfExist(surface_id);
  66         if(ret){
  67             HMI_DEBUG("wm", "remove surface %d from Client %s finish", surface_id, x.second->appID().c_str());
  68             break;
  69         }
  70     }
  71 }
  72
  73 /**
  74  * @brief  get WMClient object. Before call this function, must call "contains"
  75  * to check the key is contained, otherwise, you have to take care of std::out_of_range.
  76  * @param string[in] application id(key)
  77  * @return WMClient object
  78  */
  79 shared_ptr<WMClient> AppList::lookUpClient(const string &appid)
  80 {
  81     return this->app2client.at(appid);
  82 }
  83
  84 int AppList::countClient() const
  85 {
  86     return this->app2client.size();
  87 }
  88
  89 unsigned AppList::currentRequestNumber() const
  90 {
  91     return this->current_req;
  92 }
  93
  94 WMError AppList::popFloatingSurface(unsigned pid, unsigned *surface)
  95 {
  96     WMError ret = WMError::NO_ENTRY;
  97
  98     for (auto itr = this->floating_surfaces.begin(); itr != this->floating_surfaces.end(); ++itr)
  99     {
 100         if(pid == itr->pid){
 101             *surface = itr->surface_id;
 102             itr = this->floating_surfaces.erase(itr);
 103             ret = WMError::SUCCESS;
 104             HMI_DEBUG("wm", "Erase surface %d", *surface);
 105             break;
 106         }
 107     }
 108     return ret;
 109 }
 110
 111 WMError AppList::popFloatingSurface(const std::string &appid, unsigned *surface)
 112 {
 113     HMI_ERROR("wm", "This function is not implemented");
 114     return WMError::SUCCESS;
 115 }
 116
 117 void AppList::addFloatingClient(const std::string &appid, unsigned layer, const std::string &role)
 118 {
 119 }
 120
 121 void AppList::addFloatingSurface(unsigned surface, unsigned pid)
 122 {
 123     struct FloatingSurface fsurface{surface, pid};
 124     this->floating_surfaces.push_back(fsurface);
 125 }
 126
 127 void AppList::removeFloatingSurface(unsigned surface)
 128 {
 129     for (auto itr = this->floating_surfaces.begin(); itr != this->floating_surfaces.end(); ++itr)
 130     {
 131         if (surface == itr->surface_id)
 132         {
 133             HMI_DEBUG("wm", "Erase surface %d", itr->surface_id);
 134             itr = this->floating_surfaces.erase(itr);
 135             break;
 136         }
 137     }
 138 }
 139
 140 WMError AppList::appendRole(const std::string &id, const std::string &role, unsigned surface)
 141 {
 142     WMError wm_err = WMError::NO_ENTRY;
 143     if (this->contains(id))
 144     {
 145         auto x = this->lookUpClient(id);
 146         x->addSurface(role, surface);
 147         wm_err = WMError::SUCCESS;
 148     }
 149     return wm_err;
 150 }
 151
 152 unsigned AppList::getRequestNumber(const string &appid) const
 153 {
 154     for (const auto &x : this->req_list)
 155     {
 156         // Since app will not request twice and more, comparing appid is enough?
 157         if ((x.trigger.appid == appid))
 158         {
 159             return x.req_num;
 160         }
 161     }
 162     return 0;
 163 }
 164
 165 unsigned AppList::addAllocateRequest(WMRequest req)
 166 {
 167     if (this->req_list.size() == 0)
 168     {
 169         req.req_num = current_req;
 170     }
 171     else
 172     {
 173         HMI_SEQ_DEBUG(this->current_req, "add: %d", this->req_list.back().req_num + 1);
 174         req.req_num = this->req_list.back().req_num + 1;
 175     }
 176     this->req_list.push_back(req);
 177     return req.req_num; // return 1; if you test time_expire
 178 }
 179
 180 struct WMTrigger AppList::getRequest(unsigned req_num)
 181 {
 182     for (const auto &x : this->req_list)
 183     {
 184         if (req_num == x.req_num)
 185         {
 186             return x.trigger;
 187         }
 188     }
 189 }
 190
 191 const vector<struct WMAction> &AppList::getActions(unsigned req_num)
 192 {
 193     for (auto &x : this->req_list)
 194     {
 195         if (req_num == x.req_num)
 196         {
 197             return x.sync_draw_req;
 198         }
 199     }
 200 }
 201
 202 WMError AppList::setAction(unsigned req_num, const struct WMAction &action)
 203 {
 204     WMError result = WMError::FAIL;
 205     for (auto &x : this->req_list)
 206     {
 207         if (req_num != x.req_num)
 208         {
 209             continue;
 210         }
 211         x.sync_draw_req.push_back(action);
 212         result = WMError::SUCCESS;
 213         break;
 214     }
 215
 216     return result;
 217 }
 218
 219 /**
 220  * Note:
 221  * This function set action with parameters.
 222  * if visible is true, it means app should be visible, so enddraw_finished parameter should be false.
 223  * otherwise (visible is false) app should be invisible. Then enddraw_finished param is set to true.
 224  * This function doesn't support actions for focus yet.
 225  */
 226 WMError AppList::setAction(unsigned req_num, const string &appid, const string &role, const string &area, bool visible)
 227 {
 228     WMError result = WMError::NOT_REGISTERED;
 229     for (auto &x : req_list)
 230     {
 231         if (req_num != x.req_num)
 232         {
 233             continue;
 234         }
 235         bool edraw_f = (visible) ? false : true;
 236         WMAction action{appid, role, area, visible, edraw_f};
 237
 238         x.sync_draw_req.push_back(action);
 239         result = WMError::SUCCESS;
 240         break;
 241     }
 242     return result;
 243 }
 244
 245 /**
 246  * This function checks
 247  *   * req_num is equal to current request number
 248  *   * appid and role are equeal to the appid and role stored in action list(sync_draw_req)
 249  */
 250 bool AppList::setEndDrawFinished(unsigned req_num, const string &appid, const string &role)
 251 {
 252     bool result = false;
 253     for (auto &x : req_list)
 254     {
 255         if (req_num < x.req_num)
 256         {
 257             break;
 258         }
 259         if (req_num == x.req_num)
 260         {
 261             for (auto &y : x.sync_draw_req)
 262             {
 263                 if (y.appid == appid && y.role == role)
 264                 {
 265                     y.end_draw_finished = true;
 266                     result = true;
 267                 }
 268             }
 269         }
 270     }
 271     this->reqDump();
 272     return result;
 273 }
 274
 275 /**
 276  * @brief  check all actions of the requested sequence is finished
 277  * @param  unsigned request_number
 278  * @return true if all action is set.
 279  */
 280 bool AppList::endDrawFullfilled(unsigned req_num)
 281 {
 282     bool result = false;
 283     for (const auto &x : req_list)
 284     {
 285         if (req_num < x.req_num)
 286         {
 287             break;
 288         }
 289         if (req_num == x.req_num)
 290         {
 291             result = true;
 292             for (const auto &y : x.sync_draw_req)
 293             {
 294                 result &= y.end_draw_finished;
 295                 if (!result)
 296                 {
 297                     break;
 298                 }
 299             }
 300         }
 301     }
 302     return result;
 303 }
 304
 305 void AppList::removeRequest(unsigned req_num)
 306 {
 307     this->req_list.erase(remove_if(this->req_list.begin(), this->req_list.end(),
 308                                    [req_num](WMRequest x) {
 309                                        return x.req_num == req_num;
 310                                    }));
 311 }
 312
 313 void AppList::next()
 314 {
 315     ++this->current_req;
 316     if (0 == this->current_req)
 317     {
 318         this->current_req = 1;
 319     }
 320 }
 321
 322 bool AppList::haveRequest() const
 323 {
 324     return !this->req_list.empty();
 325 }
 326
 327 void AppList::clientDump()
 328 {
 329     DUMP("======= client dump =====");
 330     for (const auto &x : this->app2client)
 331     {
 332         const auto &y = x.second;
 333         y->dumpInfo();
 334     }
 335     DUMP("======= client dump end=====");
 336 }
 337
 338 void AppList::reqDump()
 339 {
 340     DUMP("======= req dump =====");
 341     DUMP("current request : %d", current_req);
 342     for (const auto &x : req_list)
 343     {
 344         DUMP("requested with  : %d", x.req_num);
 345         DUMP("Trigger : (APPID :%s, ROLE :%s, AREA :%s, TASK: %d)",
 346              x.trigger.appid.c_str(),
 347              x.trigger.role.c_str(),
 348              x.trigger.area.c_str(),
 349              x.trigger.task);
 350
 351         for (const auto &y : x.sync_draw_req)
 352         {
 353             DUMP(
 354                 "Action  : (APPID :%s, ROLE :%s, AREA :%s, END_DRAW_FINISHED: %d)",
 355                 y.appid.c_str(),
 356                 y.role.c_str(),
 357                 y.area.c_str(),
 358                 y.end_draw_finished);
 359         }
 360     }
 361     DUMP("======= req dump end =====\n");
 362 }
 363 } // namespace wm