src/homescreen/CicoHSAppInfo.cpp

   1 /*
   2  * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
   3  *
   4  * This program is licensed under the terms and conditions of the
   5  * Apache License, version 2.0.  The full text of the Apache License is at
   6  * http://www.apache.org/licenses/LICENSE-2.0
   7  *
   8  */
   9
  10 //==========================================================================
  11 /**
  12  *  @file   CicoHSAppInfo
  13  *
  14  *  @brief  This file is implimention of CicoHSAppInfo class
  15  */
  16 //==========================================================================
  17
  18 #include "CicoHSAppInfo.h"
  19 #include "CicoSystemConfig.h"
  20 #include "CicoConf.h"
  21 #include "CicoHSLifeCycleController.h"
  22
  23 //==========================================================================
  24 //  public functions
  25 //==========================================================================
  26 //--------------------------------------------------------------------------
  27 /**
  28  *  @brief  constractor
  29  *
  30  *  @param [in] appid   application id
  31  */
  32 //--------------------------------------------------------------------------
  33 CicoHSAppInfo::CicoHSAppInfo(const char *appid)
  34     : m_appid(appid), m_category(0), m_window_num(0), m_last_surface(0)
  35 {
  36     memset(m_window_info_i, 0, sizeof(m_window_info_i));
  37     m_life_cycle_controller = CicoHSLifeCycleController::getInstance();
  38 }
  39
  40 //--------------------------------------------------------------------------
  41 /**
  42  *  @brief   destractor
  43  */
  44 //--------------------------------------------------------------------------
  45 CicoHSAppInfo::~CicoHSAppInfo(void)
  46 {
  47 }
  48
  49 //--------------------------------------------------------------------------
  50 /**
  51  *  @brief  set window information
  52  *
  53  *  @param [in] wininfo     window information
  54  *  @return OK or ERROR
  55  */
  56 //--------------------------------------------------------------------------
  57 int
  58 CicoHSAppInfo::AddWindowInfo(ico_syc_win_info_t *wininfo)
  59 {
  60
  61     if (NULL == wininfo) {
  62         ICO_ERR("wininfo is null.");
  63         return ICO_ERROR;
  64     }
  65
  66     ICO_TRA("CicoHSAppInfo::AddWindowInfo Enter(appid=%s surface=%x",
  67             wininfo->appid, wininfo->surface);
  68
  69     // if exist window information, update current window information
  70     std::vector<ico_hs_window_info*>::iterator itr;
  71     itr = this->m_window_info.begin();
  72     for (; itr != this->m_window_info.end(); ++itr) {
  73         if (wininfo->surface == (*itr)->surface) {
  74             /*update*/
  75             SetWindowInfo(*itr, wininfo);
  76             ICO_TRA("CicoHSAppInfo::AddWindowInfo Leave(OK)");
  77             return ICO_OK;
  78         }
  79     }
  80
  81     // if not exit window information, create window information
  82     ico_hs_window_info *tmp_win_info = GetFreeWindowInfoBuffer();
  83     if (tmp_win_info == NULL) {
  84         ICO_ERR("CicoHSAppInfo::AddWindowInfo Leave(ERR)");
  85         return ICO_ERROR;
  86     }
  87     SetWindowInfo(tmp_win_info, wininfo);
  88     this->m_window_info.push_back(tmp_win_info);
  89     ++m_window_num;
  90
  91     ICO_TRA("CicoHSAppInfo::AddWindowInfo Leave(OK)");
  92     return ICO_OK;
  93 }
  94
  95 //--------------------------------------------------------------------------
  96 /**
  97  *  @brief   set window attribute
  98  *
  99  *  @param [in]   winattr   window attribute
 100  *  @return OK or ERROR
 101  */
 102 //--------------------------------------------------------------------------
 103 int
 104 CicoHSAppInfo::AddWindowAttr(ico_syc_win_attr_t *winattr)
 105 {
 106     if (NULL == winattr) {
 107         ICO_ERR("winattr is null.");
 108         return ICO_ERROR;
 109     }
 110
 111     ICO_TRA("CicoHSAppInfo::AddWindowAttr Enter(appid=%s surface=%x",
 112             winattr->appid, winattr->surface);
 113
 114     // if exist window information, update current window information
 115     std::vector<ico_hs_window_info*>::iterator itr;
 116     itr = m_window_info.begin();
 117     for (; itr != m_window_info.end(); itr++){
 118         if (winattr->surface == (*itr)->surface) {
 119             /*update*/
 120             SetWindowAttr(*itr, winattr);
 121             ICO_TRA("CicoHSAppInfo::AddWindowAttr Leave(OK)");
 122             return ICO_OK;
 123         }
 124     }
 125
 126     // if not exit window information, create window information
 127     ico_hs_window_info *tmp_win_info = GetFreeWindowInfoBuffer();
 128     if (tmp_win_info == NULL){
 129         ICO_TRA("CicoHSAppInfo::AddWindowAttr Leave(ERR)");
 130         return ICO_ERROR;
 131     }
 132
 133     SetWindowAttr(tmp_win_info, winattr);
 134     m_window_info.push_back(tmp_win_info);
 135     ++m_window_num;
 136
 137     ICO_TRA("CicoHSAppInfo::AddWindowAttr Leave(OK)");
 138     return ICO_OK;
 139 }
 140
 141 //--------------------------------------------------------------------------
 142 /**
 143  *  @brief  free window information
 144  *
 145  *  @param [in] name    window name
 146  */
 147 //--------------------------------------------------------------------------
 148 void
 149 CicoHSAppInfo::FreeWindowInfo(const char *name)
 150 {
 151     std::vector<ico_hs_window_info*>::iterator itr;
 152     itr = m_window_info.begin();
 153     for (; itr != m_window_info.end(); ++itr) {
 154         if ((0 == strncmp(name,(*itr)->name, ICO_HS_MAX_WINDOW_NAME)) &&
 155             ((*itr)->valid))    {
 156             ICO_DBG("CicoHSAppInfo::FreeWindowInfo(name=%s)", name ? name : "(NULL)");
 157             if ((*itr)->surface == m_last_surface)  {
 158                 m_last_surface = 0;
 159             }
 160             (*itr)->valid = false;
 161             m_window_info.erase(itr);
 162             -- m_window_num;
 163             break;
 164         }
 165     }
 166 }
 167
 168 //--------------------------------------------------------------------------
 169 /**
 170  *  @brief  free window information
 171  *
 172  *  @param [in] surface surface id
 173  */
 174 //--------------------------------------------------------------------------
 175 void
 176 CicoHSAppInfo::FreeWindowInfo(int surface)
 177 {
 178     std::vector<ico_hs_window_info*>::iterator itr;
 179     itr = m_window_info.begin();
 180     for (; itr != m_window_info.end(); ++itr) {
 181         if (((*itr)->surface == surface) && ((*itr)->valid))    {
 182             ICO_DBG("CicoHSAppInfo::FreeWindowInfo(surface=%08x)", surface);
 183             if ((*itr)->surface == m_last_surface)  {
 184                 m_last_surface = 0;
 185             }
 186             (*itr)->valid = false;
 187             m_window_info.erase(itr);
 188             -- m_window_num;
 189             break;
 190         }
 191     }
 192 }
 193
 194 //--------------------------------------------------------------------------
 195 /**
 196  *  @brief  get application id
 197  *
 198  *  @return application id
 199  */
 200 //--------------------------------------------------------------------------
 201 const char*
 202 CicoHSAppInfo::GetAppId(void)
 203 {
 204     return m_appid.c_str();
 205 }
 206
 207 //--------------------------------------------------------------------------
 208 /**
 209  *  @brief  get number of window
 210  *
 211  *  @return number of window
 212  */
 213 //--------------------------------------------------------------------------
 214 int
 215 CicoHSAppInfo::GetWindowNum(void)
 216 {
 217     return m_window_num;
 218 }
 219
 220 //--------------------------------------------------------------------------
 221 /**
 222  *  @brief  get window information
 223  *
 224  *  @param[in]   name   window name
 225  *  @return window information
 226  */
 227 //--------------------------------------------------------------------------
 228 ico_hs_window_info*
 229 CicoHSAppInfo::GetWindowInfo(const char* name)
 230 {
 231     std::vector<ico_hs_window_info*>::iterator itr;
 232     itr = m_window_info.begin();
 233     for (; itr != m_window_info.end(); ++itr) {
 234         if((0 == strncmp(name,(*itr)->name, ICO_HS_MAX_WINDOW_NAME)) &&
 235            ((*itr)->valid)) {
 236             return *itr;
 237         }
 238     }
 239     return NULL;
 240 }
 241
 242 /*--------------------------------------------------------------------------*/
 243 /**
 244  * @brief   CicoHSAppInfo::GetWindowInfo
 245  *          get window information
 246  *
 247  * @param[in]   idx index(0-n)
 248  * @return      window information
 249  */
 250 /*--------------------------------------------------------------------------*/
 251 ico_hs_window_info*
 252 CicoHSAppInfo::GetWindowInfo(int idx)
 253 {
 254     int     i = 0;
 255
 256     for (std::vector<ico_hs_window_info*>::iterator it_window_info
 257                 = m_window_info.begin();
 258          it_window_info != m_window_info.end();
 259          it_window_info++) {
 260         if (! (*it_window_info)->valid) continue;
 261         if (i >= idx)   {
 262             return *it_window_info;
 263         }
 264         i ++;
 265     }
 266     return NULL;
 267 }
 268
 269 //--------------------------------------------------------------------------
 270 /**
 271  *  @brief  get window information
 272  *
 273  *  @param[in]   surface    surface id
 274  *  @return window information
 275  */
 276 //--------------------------------------------------------------------------
 277 ico_hs_window_info*
 278 CicoHSAppInfo::GetWindowInfobySurface(int surface)
 279 {
 280     std::vector<ico_hs_window_info*>::iterator itr;
 281     itr = m_window_info.begin();
 282     for (; itr != m_window_info.end(); ++itr) {
 283         if (((*itr)->surface == surface) &&
 284             ((*itr)->valid))    {
 285             return *itr;
 286         }
 287     }
 288     return NULL;
 289 }
 290
 291 //--------------------------------------------------------------------------
 292 /**
 293  *  @brief   launch application
 294  *
 295  *  @return 0 on success, other on error
 296  */
 297 //--------------------------------------------------------------------------
 298 int
 299 CicoHSAppInfo::Execute(void)
 300 {
 301     // call launch api
 302     int ret = m_life_cycle_controller->launch(m_appid);
 303     if (ret < 0) {
 304         return ret;
 305     }
 306     return ret;
 307 }
 308
 309 //--------------------------------------------------------------------------
 310 /*
 311  *  @brief  terminate application
 312  *
 313  *  @return 0 on success, other on error
 314  */
 315 //--------------------------------------------------------------------------
 316 int
 317 CicoHSAppInfo::Terminate(void)
 318 {
 319     // call terminate api
 320     int ret = m_life_cycle_controller->terminate(m_appid);
 321     if(ret < 0){
 322         return ret;
 323     }
 324     return ret;
 325 }
 326
 327 //--------------------------------------------------------------------------
 328 /**
 329  *  @brief  get status
 330  *
 331  *  @return application running status
 332  *  @retval true    running
 333  *  @retval false   not running
 334  */
 335 //--------------------------------------------------------------------------
 336 bool
 337 CicoHSAppInfo::GetStatus(void)
 338 {
 339     return m_life_cycle_controller->isRunning(m_appid);
 340 }
 341
 342 //--------------------------------------------------------------------------
 343 /**
 344  *  @brief  set last surface id
 345  *
 346  *  @param [in] last surface id
 347  */
 348 //--------------------------------------------------------------------------
 349 void
 350 CicoHSAppInfo::SetLastSurface(int last_surface)
 351 {
 352     m_last_surface = last_surface;
 353 }
 354
 355 //--------------------------------------------------------------------------
 356 /**
 357  *  @brief  get last surface id
 358  *
 359  *  @return surface id
 360  */
 361 //--------------------------------------------------------------------------
 362 int
 363 CicoHSAppInfo::GetLastSurface(void)
 364 {
 365     return m_last_surface;
 366 }
 367
 368 //--------------------------------------------------------------------------
 369 /**
 370  *  @brief  get default zone name
 371  *
 372  *  @return zone name
 373  */
 374 //--------------------------------------------------------------------------
 375 const char *
 376 CicoHSAppInfo::GetDefaultZone(void)
 377 {
 378     m_life_cycle_controller = CicoHSLifeCycleController::getInstance();
 379     const CicoAilItems* ailItem = m_life_cycle_controller->findAIL(m_appid);
 380
 381     CicoSystemConfig *sysConf = CicoSystemConfig::getInstance();
 382     const CicoSCDisplayZoneConf *zoneConf = NULL;
 383     if (NULL != ailItem) {
 384         zoneConf = sysConf->findDisplayZoneConfbyId(ailItem->m_displayZone);
 385     }
 386     else {
 387         const CicoSCDefaultConf* defConf = sysConf->getDefaultConf();
 388         zoneConf = sysConf->findDisplayZoneConfbyId(defConf->displayzone);
 389     }
 390
 391     if (NULL == zoneConf) {
 392         return NULL;
 393     }
 394     return zoneConf->fullname.c_str();
 395 }
 396
 397 //==========================================================================
 398 //  private method
 399 //==========================================================================
 400 //--------------------------------------------------------------------------
 401 /**
 402  *  @brief   set window information
 403  *
 404  *  @param [in] hs_wininfo  window information
 405  *  @param [in] wininfo     window information from system-controller
 406  */
 407 //--------------------------------------------------------------------------
 408 void
 409 CicoHSAppInfo::SetWindowInfo(ico_hs_window_info *hs_wininfo,
 410                              ico_syc_win_info_t *wininfo)
 411 {
 412     ICO_TRA("CicoHSAppInfo::SetWindowInfo Enter"
 413             "(winifo=%p appid=%s winname=%s surface=%x)",
 414             hs_wininfo,
 415             wininfo->appid, wininfo->name, wininfo->surface);
 416
 417     // set application id
 418     if(wininfo->appid != NULL){
 419         strncpy(hs_wininfo->appid, wininfo->appid, ICO_HS_MAX_PROCESS_NAME);
 420     }
 421
 422     // set window name(window title)
 423     if(wininfo->name != NULL){
 424         strncpy(hs_wininfo->name, wininfo->name, ICO_HS_MAX_WINDOW_NAME);
 425     }
 426     // set surface id
 427     hs_wininfo->surface = wininfo->surface;
 428
 429     ICO_TRA("CicoHSAppInfo::SetWindowInfo Leave");
 430 }
 431
 432 //--------------------------------------------------------------------------
 433 /**
 434  *  @brief  set window attribute
 435  *
 436  *  @param [in] hs_wininfo  window information
 437  *  @param [in] winattr     window attribute
 438  */
 439 //--------------------------------------------------------------------------
 440 void
 441 CicoHSAppInfo::SetWindowAttr(ico_hs_window_info *hs_wininfo,
 442                              ico_syc_win_attr_t *winattr)
 443 {
 444     ICO_TRA("CicoHSAppInfo::SetWindowAttr Enter"
 445             "(winifo=%p "
 446             "appid=%s winname=%s zone=%s surface=%x nodeid=%d layer=%d "
 447             "x/y=%d/%d w/h=%d/%d raise=%d visible=%d active=%d)",
 448             hs_wininfo,
 449             winattr->appid, winattr->name, winattr->zone,
 450             winattr->surface, winattr->nodeid, winattr->layer,
 451             winattr->pos_x, winattr->pos_y, winattr->width, winattr->height,
 452             winattr->raise, winattr->visible, winattr->active);
 453
 454     if (winattr->appid != NULL) {
 455         strncpy(hs_wininfo->appid, winattr->appid, ICO_HS_MAX_PROCESS_NAME);
 456     }
 457
 458     if (winattr->name != NULL) {
 459         strncpy(hs_wininfo->name, winattr->name, ICO_HS_MAX_WINDOW_NAME);
 460     }
 461
 462     if (winattr->zone != NULL) {
 463         strncpy(hs_wininfo->zone, winattr->zone, ICO_HS_MAX_ZONE_NAME);
 464     }
 465
 466     hs_wininfo->surface = winattr->surface;
 467     hs_wininfo->nodeid  = winattr->nodeid;
 468     hs_wininfo->layer   = winattr->layer;
 469     hs_wininfo->pos_x   = winattr->pos_x;
 470     hs_wininfo->pos_y   = winattr->pos_y;
 471     hs_wininfo->width   = winattr->width;
 472     hs_wininfo->height  = winattr->height;
 473     hs_wininfo->raise   = winattr->raise;
 474     hs_wininfo->visible = winattr->visible;
 475     hs_wininfo->active  = winattr->active;
 476
 477     ICO_TRA("CicoHSAppInfo::SetWindowAttr Leave");
 478 }
 479
 480 //--------------------------------------------------------------------------
 481 /**
 482  * @brief   CicoHSAppInfo::GetFreeWindowInfoBuffer
 483  *          get internal window info buffer
 484  *
 485  * @param[in]   none
 486  * @return      buffer
 487  */
 488 //--------------------------------------------------------------------------
 489 ico_hs_window_info *
 490 CicoHSAppInfo::GetFreeWindowInfoBuffer(void)
 491 {
 492     ico_hs_window_info *tmp_win_info;
 493     for (int ii = 0; ii < ICO_HS_APP_MAX_WINDOW_NUM; ii++) {
 494         if (m_window_info_i[ii].valid == false) {
 495            tmp_win_info = &m_window_info_i[ii];
 496            tmp_win_info->valid = true;
 497            return tmp_win_info;
 498         }
 499     }
 500     return NULL;
 501 }
 502 // vim: set expandtab ts=4 sw=4: