src/homescreen/CicoHomeScreen.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  * @brief   Home Screen
  11  *
  12  * @date    Aug-08-2013
  13  */
  14 #include <string>
  15 #include <vector>
  16 #include <cstdlib>
  17 #include "CicoHSAppHistory.h"
  18 #include "CicoHSAppHistoryExt.h"
  19 #include "CicoHomeScreen.h"
  20 #include "CicoHSSystemState.h"
  21 #include "CicoHSLifeCycleController.h"
  22 #include "CicoConf.h"
  23 #include "CicoHSCmdOpts.h"
  24 #include "Cico_aul_listen_app.h"
  25 #include "CicoLibString.h"
  26 #include "CicoHSServer.h"
  27 #include "CicoHSAppControl.h"
  28 #include "CicoSound.h"
  29 using namespace std;
  30
  31 /*============================================================================*/
  32 /* static members                                                             */
  33 /*============================================================================*/
  34 CicoHomeScreen * CicoHomeScreen::hs_instance;
  35
  36 /*============================================================================*/
  37 /* functions                                                                  */
  38 /*============================================================================*/
  39
  40 /**
  41  * ecore timer void data typedef
  42  */
  43 typedef struct t_launcApps_data {
  44     string filePath;
  45     string filePathD;
  46     CicoHomeScreen *hs;
  47 } launcApps_data_t;
  48
  49 /*--------------------------------------------------------------------------*/
  50 /**
  51  * @brief   CicoHomeScreen::CicoHomeScreen
  52  *          Constractor
  53  *
  54  * @param[in]   none
  55  * @return      none
  56  */
  57 /*--------------------------------------------------------------------------*/
  58 CicoHomeScreen::CicoHomeScreen(void)
  59 {
  60     application_num = 0;
  61     for(int ii = 0;ii < ICO_HS_MAX_APP_NUM;ii++){
  62         apps_info[ii] = NULL;
  63     }
  64     active_appinfo = NULL;
  65
  66     hs_app_info = NULL;
  67     sb_app_info = NULL;
  68     os_app_info = NULL;
  69
  70     full_width = 1;
  71     full_height = 1;
  72     menu_width = 1;
  73     menu_height = 1;
  74     bg_width = 1;
  75     bg_height = 1;
  76     ctl_bar_width = 1;
  77     ctl_bar_height = 1;
  78     num_swipe_input_windows = 0;
  79
  80     menu_window = NULL;
  81     back_window = NULL;
  82     ctl_bar_window = NULL;
  83
  84     //mode = ICO_HS_MODE_MENU;
  85     mode = ICO_HS_MODE_APPLICATION;
  86     config = NULL;
  87     hs_instance = NULL;
  88
  89     m_appHis = NULL;
  90
  91     life_cycle_controller = CicoHSLifeCycleController::getInstance();
  92
  93     sub_display_appinfo = NULL;
  94 }
  95
  96 /*--------------------------------------------------------------------------*/
  97 /**
  98  * @brief   CicoHomeScreen::~CicoHomeScreen
  99  *          Destractor
 100  *
 101  * @param[in]   none
 102  * @return      none
 103  */
 104 /*--------------------------------------------------------------------------*/
 105 CicoHomeScreen::~CicoHomeScreen(void)
 106 {
 107     /* Do not somthing to do */
 108     if (NULL != m_appHis) {
 109         delete m_appHis;
 110     }
 111 }
 112
 113 //--------------------------------------------------------------------------
 114 /**
 115  *  @brief  get this class instance
 116  */
 117 //--------------------------------------------------------------------------
 118 CicoHomeScreen*
 119 CicoHomeScreen::getInstance(void)
 120 {
 121     return hs_instance;
 122 }
 123
 124 /*--------------------------------------------------------------------------*/
 125 /**
 126  * @brief   CicoHomeScreen::ShowHomeScreenLayer
 127  *          Show Home screen layer
 128  *
 129  * @param[in]   none
 130  * @return      none
 131  */
 132 /*--------------------------------------------------------------------------*/
 133 void
 134 CicoHomeScreen::ShowHomeScreenLayer(void)
 135 {
 136     /*show home screen layers*/
 137     ico_syc_show_layer(HS_LAYER_APPLICATION);
 138     ico_syc_show_layer(HS_LAYER_HOMESCREEN);
 139     ico_syc_show_layer(HS_LAYER_CONTROLBAR);
 140     ico_syc_show_layer(HS_LAYER_TOUCHPANEL);
 141 }
 142
 143 /*--------------------------------------------------------------------------*/
 144 /**
 145  * @brief   CicoHomeScreen::GetHsPackageName
 146  *          get HomeScreen package name
 147  *
 148  * @param[in]   none
 149  * @return      package name
 150  */
 151 /*--------------------------------------------------------------------------*/
 152 char *
 153 CicoHomeScreen::GetHsPackageName(void)
 154 {
 155     return hs_package_name;
 156 }
 157
 158 /*--------------------------------------------------------------------------*/
 159 /**
 160  * @brief   CicoHomeScreen::GetHsPackageName
 161  *          get StatusBar package name
 162  *
 163  * @param[in]   none
 164  * @return      package name
 165  */
 166 /*--------------------------------------------------------------------------*/
 167 char *
 168 CicoHomeScreen::GetSbPackageName(void)
 169 {
 170     return sb_package_name;
 171 }
 172
 173 /*--------------------------------------------------------------------------*/
 174 /**
 175  * @brief   CicoHomeScreen::GetHsPackageName
 176  *          get OnScreen package name
 177  *
 178  * @param[in]   none
 179  * @return      package name
 180  */
 181 /*--------------------------------------------------------------------------*/
 182 char *
 183 CicoHomeScreen::GetOsPackageName(void)
 184 {
 185     return os_package_name;
 186 }
 187
 188 /*--------------------------------------------------------------------------*/
 189 /**
 190  * @brief   CicoHomeScreen::CreateAppInfoList
 191  *          create application info list
 192  *
 193  * @param[in]   none
 194  * @return      none
 195  */
 196 /*--------------------------------------------------------------------------*/
 197 void
 198 CicoHomeScreen::CreateAppInfoList(void)
 199 {
 200     /* get APP information*/
 201     std::vector<CicoAilItems> aillist = life_cycle_controller->getAilList();
 202
 203     for (int ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
 204         if (apps_info[ii] != NULL)  {
 205             delete apps_info[ii];
 206         }
 207     }
 208
 209     /*create instance*/
 210     application_num = 0;
 211     for (unsigned int ii = 0;
 212          (ii < aillist.size()) && (ii < ICO_HS_MAX_APP_NUM);
 213          ii++)  {
 214         apps_info[ii] = new CicoHSAppInfo(aillist[ii].m_appid.c_str());
 215         application_num++;
 216     }
 217 }
 218
 219 /*--------------------------------------------------------------------------*/
 220 /**
 221  * @brief   CicoHomeScreen::GetAppInfo
 222  *          get application info
 223  *
 224  * @param[in]   appid    application id
 225  * @return      Application info
 226  */
 227 /*--------------------------------------------------------------------------*/
 228 CicoHSAppInfo *
 229 CicoHomeScreen::GetAppInfo(const char *appid)
 230 {
 231     if (NULL == appid) {
 232         return NULL;
 233     }
 234
 235     for (int ii = 0;ii < hs_instance->application_num;ii++) {
 236         if (strcmp(hs_instance->apps_info[ii]->GetAppId(),appid) == 0)   {
 237             return hs_instance->apps_info[ii];
 238         }
 239     }
 240     return NULL;
 241 }
 242
 243 /*--------------------------------------------------------------------------*/
 244 /**
 245  * @brief   CicoHomeScreen::GetAppStatus
 246  *          get application status
 247  *
 248  * @param[in]   appid    application id
 249  * @return      Application info
 250  */
 251 /*--------------------------------------------------------------------------*/
 252 bool
 253 CicoHomeScreen::GetAppStatus(const char *appid)
 254 {
 255     for (int ii = 0;ii < hs_instance->application_num;ii++) {
 256         if (strcmp(hs_instance->apps_info[ii]->GetAppId(),appid) == 0)  {
 257             return hs_instance->apps_info[ii]->GetStatus();
 258         }
 259     }
 260     return false;
 261 }
 262
 263 /*--------------------------------------------------------------------------*/
 264 /**
 265  * @brief   change active window
 266  */
 267 /*--------------------------------------------------------------------------*/
 268 void
 269 CicoHomeScreen::ChangeActive(const char * appid, int surface)
 270 {
 271     CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(appid);
 272     if (appinfo == NULL)    {
 273         return;
 274     }
 275
 276     ico_hs_window_info* wininfo = appinfo->GetWindowInfobySurface(surface);
 277     if (wininfo == NULL) {
 278         return;
 279     }
 280
 281     appinfo->SetLastSurface(surface);
 282
 283     // if window invisible, not update active information
 284     if (0 != wininfo->visible) {
 285         hs_instance->SetActiveAppInfo(appid);
 286         hs_instance->setActiveApp(appid);
 287         ICO_TRA("CicoHomeScreen::ChangeActive set show");
 288         ico_syc_show(appid, surface, NULL);
 289         ico_syc_change_active(appid, surface);
 290     }
 291 }
 292
 293 /*--------------------------------------------------------------------------*/
 294 /**
 295  * @brief   change application display zone for active window
 296  */
 297 /*--------------------------------------------------------------------------*/
 298 void
 299 CicoHomeScreen::ChangeZone(void)
 300 {
 301     ICO_TRA("CicoHomeScreen::ChangeZone Enter");
 302
 303     hs_instance->controlRegulation();
 304
 305     CicoHSAppInfo* appinfo = hs_instance->GetSubDisplayAppInfo();
 306     // if sub display not exist showed appliction,
 307     // get main display showed application informaiton
 308     if (NULL == appinfo) {
 309         appinfo = hs_instance->GetActiveAppInfo();
 310         if (NULL == appinfo) {
 311             ICO_TRA("CicoHomeScreen::ChangeZone Leave(not found appinfo)");
 312             return;
 313         }
 314     }
 315     hs_instance->requestChangeZone(appinfo);
 316     ICO_TRA("CicoHomeScreen::ChangeZone Leave");
 317 }
 318
 319 /*--------------------------------------------------------------------------*/
 320 /**
 321  * @brief   change application display zone for appinfo
 322  */
 323 /*--------------------------------------------------------------------------*/
 324 void
 325 CicoHomeScreen::requestChangeZone(CicoHSAppInfo* appinfo)
 326 {
 327     int surface = appinfo->GetLastSurface();
 328     ICO_TRA("Enter appid=%s, lastsurface=%x", appinfo->GetAppId(), surface);
 329     ico_hs_window_info* wininfo = appinfo->GetWindowInfobySurface(surface);
 330     if (NULL == wininfo) {
 331         ICO_TRA("Leave(not found wininfo)");
 332         return;
 333     }
 334     ICO_DBG("wininfo=%p", wininfo);
 335
 336     const char *dispzone = moveZoneName;
 337     int layer = HS_LAYER_2NDDISP_APP;
 338     if (NULL != GetSubDisplayAppInfo()) {
 339         dispzone = appinfo->GetDefaultZone();
 340         layer = HS_LAYER_APPLICATION;
 341     }
 342
 343     if (NULL == dispzone) {
 344         ICO_TRA("Leave(not found dispzone)");
 345         return;
 346     }
 347
 348     ICO_DBG("change zone: \"%s\"->\"%s\"", wininfo->zone, dispzone);
 349     ico_syc_win_move_t move = {
 350         .zone   = (char*)dispzone,
 351         .layer  = layer,
 352         .pos_x  = 0,
 353         .pos_y  = 0,
 354         .width  = 0,
 355         .height = 0
 356     };
 357
 358     ico_syc_move(wininfo->appid, wininfo->surface, &move,
 359                  &hs_instance->moveZoneAnimation);
 360
 361     ICO_TRA("Leave");
 362 }
 363
 364 /*--------------------------------------------------------------------------*/
 365 /**
 366  * @brief   CicoHomeScreen::GetWindowInfo
 367  *          get window info
 368  *
 369  * @param[in]   appinfo    application info
 370  * @param[in]   window    window name
 371  * @return      Window info
 372  */
 373 /*--------------------------------------------------------------------------*/
 374 ico_hs_window_info *
 375 CicoHomeScreen::GetWindowInfo(CicoHSAppInfo *appinfo,const char *window)
 376 {
 377     return appinfo->GetWindowInfo(window);
 378 }
 379
 380 /*--------------------------------------------------------------------------*/
 381 /**
 382  * @brief   CicoHomeScreen::GetWindowInfo
 383  *          get window info
 384  *
 385  * @param[in]   appinfo    application info
 386  * @param[in]   surface    surface id
 387  * @return      Window info
 388  */
 389 /*--------------------------------------------------------------------------*/
 390 ico_hs_window_info *
 391 CicoHomeScreen::GetWindowInfo(CicoHSAppInfo *appinfo, int surface)
 392 {
 393     return appinfo->GetWindowInfobySurface(surface);
 394 }
 395
 396 /*--------------------------------------------------------------------------*/
 397 /**
 398  * @brief   CicoHomeScreen::UpdateTile
 399  *          update tile image
 400  *
 401  * @param[in]   appid    application id
 402  * @return      Window info
 403  */
 404 /*--------------------------------------------------------------------------*/
 405 void
 406 CicoHomeScreen::UpdateTile(const char *appid)
 407 {
 408     CicoHSAppInfo *appinfo = GetAppInfo(appid);
 409     if (appinfo == NULL)    {
 410         return;
 411     }
 412     if (appinfo->GetStatus() == false)  {
 413         //show icon
 414         ICO_DBG("CicoHomeScreen::UpdateTile: show menuIcon(%s)", appid);
 415         menu_window->ValidMenuIcon(appid);
 416     }
 417     else    {
 418         //show thumbnail
 419         ICO_DBG("CicoHomeScreen::UpdateTile: show app thumbnail(%s)", appid);
 420         menu_window->ValidThumbnail(appid, appinfo->GetLastSurface());
 421     }
 422 }
 423
 424 /*--------------------------------------------------------------------------*/
 425 /**
 426  *  @brief  set current active application information
 427  *
 428  *  @param [in] appid    application id
 429  */
 430 /*--------------------------------------------------------------------------*/
 431 void
 432 CicoHomeScreen::SetActiveAppInfo(const char *appid)
 433 {
 434     CicoHSAppInfo* appinfo = NULL;
 435     if (NULL != appid) {
 436         appinfo = GetAppInfo(appid);
 437
 438         // if active window is HomeScreen/StatusBar/OnScreen,
 439         // not update active application information
 440         ICO_DBG("appinfo=%08x hs_app_info=%08x sb_app_info=%08x os_app_info=%08x",
 441                 appinfo, hs_app_info, sb_app_info, os_app_info);
 442         if ((appinfo == hs_app_info) ||
 443             (appinfo == sb_app_info) ||
 444             (appinfo == os_app_info)) {
 445             return;
 446         }
 447     }
 448     ICO_DBG("active application changed. \"%s\"->\"%s\"",
 449             active_appinfo ? active_appinfo->GetAppId() : "unknown",
 450             appinfo ? appinfo->GetAppId() : "unknown");
 451
 452     active_appinfo = appinfo;
 453 }
 454
 455 /*--------------------------------------------------------------------------*/
 456 /**
 457  *  @brief  update current active application information
 458  *
 459  *  @param [in] appid    application id
 460  */
 461 /*--------------------------------------------------------------------------*/
 462 CicoHSAppInfo *
 463 CicoHomeScreen::GetActiveAppInfo(void)
 464 {
 465     return active_appinfo;
 466 }
 467
 468 /*--------------------------------------------------------------------------*/
 469 /**
 470  *  @brief  set current sub display application information
 471  *
 472  *  @param [in] appid    application id
 473  */
 474 /*--------------------------------------------------------------------------*/
 475 void
 476 CicoHomeScreen::SetSubDisplayAppInfo(const char *appid)
 477 {
 478     if (NULL == appid) {
 479         if (NULL == sub_display_appinfo) {
 480             ICO_WRN("already not use");
 481             return;
 482         }
 483         ICO_DBG("sub display appinfo changed. \"%s\"->\"none\"",
 484                 sub_display_appinfo->GetAppId());
 485         sub_display_appinfo = NULL;
 486         return;
 487     }
 488
 489     // if sub_display_appinfo is not NULL,
 490     // not update sub display application information
 491     if (NULL != sub_display_appinfo) {
 492         ICO_WRN("sub display use. appid=%s",
 493                 sub_display_appinfo->GetAppId());
 494         return;
 495     }
 496
 497     CicoHSAppInfo* appinfo = GetAppInfo(appid);
 498
 499     // if sub display appinfo is HomeScreen/StatusBar/OnScreen,
 500     // not update sub display application information
 501     ICO_DBG("appinfo=%08x hs_app_info=%08x sb_app_info=%08x os_app_info=%08x",
 502             appinfo, hs_app_info, sb_app_info, os_app_info);
 503     if ((appinfo == hs_app_info) ||
 504         (appinfo == sb_app_info) ||
 505         (appinfo == os_app_info)) {
 506         return;
 507     }
 508
 509     if (NULL != appinfo) {
 510         ICO_DBG("sub display appinfo changed. \"none\"->\"%s\"",
 511                 appinfo->GetAppId());
 512         sub_display_appinfo = appinfo;
 513     }
 514 }
 515
 516 /*--------------------------------------------------------------------------*/
 517 /**
 518  *  @brief  update current sub display application information
 519  *
 520  */
 521 /*--------------------------------------------------------------------------*/
 522 CicoHSAppInfo *
 523 CicoHomeScreen::GetSubDisplayAppInfo(void)
 524 {
 525     return sub_display_appinfo;
 526 }
 527
 528 /*--------------------------------------------------------------------------*/
 529 /**
 530  *  @brief  update current sub display application appid
 531  *
 532  *  @return appid    application id
 533  *  @retval NULL : sub display application nothing
 534  *  @retval not NULL : appid
 535  */
 536 /*--------------------------------------------------------------------------*/
 537 const char*
 538 CicoHomeScreen::GetSubDisplayAppid(void)
 539 {
 540     if (NULL == sub_display_appinfo) {
 541         return NULL;
 542     }
 543     const char* pR = sub_display_appinfo->GetAppId();
 544     if ((NULL == pR) || (0 == pR) || (0 == strlen(pR))) {
 545         return NULL;
 546     }
 547     return pR;
 548 }
 549 /*--------------------------------------------------------------------------*/
 550 /**
 551  * @brief   CicoHomeScreen::ExecuteApp_i
 552  *          execute and showing application
 553  *
 554  * @param[in]   appid    application id
 555  * @return      none
 556  */
 557 /*--------------------------------------------------------------------------*/
 558 void
 559 CicoHomeScreen::ExecuteApp_i(const char *appid)
 560 {
 561     ICO_TRA("start %s", appid);
 562     CicoHSAppInfo *appinfo = GetAppInfo(appid);
 563     if (appinfo == NULL)    {
 564         ICO_TRA("end get appinfo is NULL");
 565         return;
 566     }
 567     if (sub_display_appinfo != appinfo) {
 568         if (appinfo->GetStatus() == false)  {
 569             //execute
 570             appinfo->Execute();
 571             ICO_DBG("execute app %s", appid);
 572         }
 573         else {
 574             //raise
 575             RaiseApplicationWindow(appinfo->GetAppId(),
 576                                    appinfo->GetLastSurface());
 577             ICO_DBG("raise app %s", appid);
 578             m_appHis->moveHistoryHead(appid);
 579         }
 580     }
 581     /* hide HomeScreen layer                        */
 582     if (GetMode() == ICO_HS_MODE_MENU)  {
 583         ChangeMode(ICO_HS_SHOW_HIDE_PATTERN_FADE);
 584     }
 585     ICO_TRA("end");
 586 }
 587
 588 /*--------------------------------------------------------------------------*/
 589 /**
 590  * @brief   CicoHomeScreen::TerminateApp_i
 591  *          teminate application
 592  *
 593  * @param[in]   appid    application id
 594  * @return      none
 595  */
 596 /*--------------------------------------------------------------------------*/
 597 void
 598 CicoHomeScreen::TerminateApp_i(const char *appid)
 599 {
 600     if (appid != NULL)  {
 601         CicoHSAppInfo *appinfo = GetAppInfo(appid);
 602         if (appinfo == NULL)    {
 603             return;
 604         }
 605
 606         //terminate
 607         appinfo->Terminate();
 608     }
 609     /* hide HomeScreen layer                        */
 610     if (GetMode() == ICO_HS_MODE_MENU)  {
 611         ChangeMode(ICO_HS_SHOW_HIDE_PATTERN_FADE);
 612     }
 613 }
 614
 615 /*--------------------------------------------------------------------------*/
 616 /**
 617  * @brief   CicoHomeScreen::ShowHomeScreenWindow
 618  *          show window (home screen)
 619  *
 620  * @param[in]   win info    window information
 621  * @return      none
 622  */
 623 /*--------------------------------------------------------------------------*/
 624 void
 625 CicoHomeScreen::ShowHomeScreenWindow(ico_syc_win_info_t *win_info)
 626 {
 627     ico_syc_win_move_t move;
 628     int layer;
 629     move.zone = NULL;
 630     move.pos_x = 0;
 631     move.width = full_width;
 632
 633     if (strncmp(win_info->name,ICO_HS_BACK_WINDOW_TITLE,
 634                 ICO_MAX_TITLE_NAME_LEN) == 0) {
 635         move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
 636         move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
 637                       ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 638         layer = HS_LAYER_BACKGROUND;
 639     }
 640     else if (strncmp(win_info->name,ICO_HS_CONTROL_BAR_WINDOW_TITLE,
 641                      ICO_MAX_TITLE_NAME_LEN) == 0) {
 642         move.pos_y = full_height - ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 643         move.height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 644         layer = HS_LAYER_CONTROLBAR;
 645     }
 646     else if (strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
 647                      ICO_MAX_TITLE_NAME_LEN) == 0) {
 648         move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
 649         move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
 650                       ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 651         layer = HS_LAYER_HOMESCREEN;
 652     }
 653     else    {
 654         /*do nothing*/
 655         return;
 656     }
 657
 658     ico_syc_change_layer(win_info->appid,win_info->surface,layer);
 659     ICO_DBG("CicoHomeScreen::ShowHomeScreenWindow: id(%s) name(%s) surface(%d) "
 660             "pos(%d,%d) size(%d,%d)", win_info->appid,
 661             win_info->name, win_info->surface, move. pos_x, move.pos_y,
 662             move.width, move.height);
 663     ico_syc_move(win_info->appid, win_info->surface, &move, NULL);
 664
 665     /*first time menu is unvisible*/
 666     if ((strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
 667                  ICO_MAX_TITLE_NAME_LEN) == 0) &&
 668         (GetMode() == ICO_HS_MODE_APPLICATION)) {
 669         return;
 670     }
 671     ico_syc_show(win_info->appid, win_info->surface,NULL);
 672 }
 673
 674 /*--------------------------------------------------------------------------*/
 675 /**
 676  * @brief   CicoHomeScreen::ShowStatusBarWindow
 677  *          show window (home screen)
 678  *
 679  * @param[in]   win info    window information
 680  * @return      none
 681  */
 682 /*--------------------------------------------------------------------------*/
 683 void
 684 CicoHomeScreen::ShowStatusBarWindow(ico_syc_win_info_t *win_info)
 685 {
 686     ico_syc_win_move_t move;
 687     int layer;
 688     move.zone = NULL;
 689     move.pos_x = 0;
 690     move.pos_y = 0;
 691     move.width = full_width;
 692     move.height = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
 693     layer = HS_LAYER_CONTROLBAR;
 694
 695     ico_syc_change_layer(win_info->appid,win_info->surface,layer);
 696     ICO_DBG("CicoHomeScreen::ShowStatusBarWindow: id(%s) name(%s) surface(%d) "
 697             "pos(%d,%d) size(%d,%d)",win_info->appid,
 698             win_info->name,win_info->surface,move.pos_x,move.pos_y,
 699             move.width,move.height);
 700     ico_syc_move(win_info->appid,win_info->surface,&move,NULL);
 701     ico_syc_show(win_info->appid, win_info->surface,NULL);
 702 }
 703
 704 /*--------------------------------------------------------------------------*/
 705 /**
 706  * @brief   CicoHomeScreen::ShowApplicationWindow
 707  *          show window (application)
 708  *
 709  * @param[in]   win info    window information
 710  * @return      none
 711  */
 712 /*--------------------------------------------------------------------------*/
 713 void
 714 CicoHomeScreen::ShowApplicationWindow(ico_syc_win_info_t *win_info)
 715 {
 716     ICO_TRA("CicoHomeScreen::ShowApplicationWindow Enter");
 717
 718     CicoHSLifeCycleController *lifecycle =
 719         CicoHSLifeCycleController::getInstance();
 720     const CicoAilItems* ailItem = lifecycle->findAIL(win_info->appid);
 721     if (NULL == ailItem) {
 722         ICO_WRN("ailItem not found.");
 723         ICO_TRA("CicoHomeScreen::ShowApplicationWindow Leave");
 724         return;
 725     }
 726     int zoneid = ailItem->m_displayZone;
 727
 728     ICO_DBG("zoneid=%d", zoneid);
 729     const CicoSCDisplayZoneConf* dispZoneConf =
 730         CicoSystemConfig::getInstance()->findDisplayZoneConfbyId(zoneid);
 731     if (NULL == dispZoneConf) {
 732         ICO_WRN("display zone config not found.");
 733         ICO_TRA("CicoHomeScreen::ShowApplicationWindow Leave");
 734         return;
 735     }
 736     ICO_DBG("appid=%s zoneid=%d:%s",
 737             win_info->appid, zoneid, dispZoneConf->fullname.c_str());
 738
 739     ico_syc_win_move_t move;
 740
 741     move.zone  = (char*)dispZoneConf->fullname.c_str();
 742     move.layer = HS_LAYER_APPLICATION;
 743     if (ailItem->m_display != 0) {
 744         move.layer = HS_LAYER_2NDDISP_APP;
 745     }
 746     move.pos_x = 0;
 747     move.width = full_width;
 748     move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
 749     move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
 750                   ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 751
 752     ico_syc_move(win_info->appid,win_info->surface,&move,NULL);
 753     ico_syc_animation_t animation;
 754     animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_FADE;
 755     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
 756     const string& lastStartupApp = m_appHis->getLastStartupAppid();
 757     if (true == lastStartupApp.empty()) {
 758         ICO_DBG("show (empty) %s", win_info->appid);
 759         ico_syc_show(win_info->appid, win_info->surface, &animation);
 760     }
 761     else {
 762         bool bShow = false;
 763         if (0 == lastStartupApp.compare(win_info->appid)) {
 764             bShow = true;
 765         }
 766         if (true == bShow) {
 767             ICO_DBG("show (last) %s", win_info->appid);
 768             ico_syc_show(win_info->appid, win_info->surface, &animation);
 769         }
 770         else {
 771             ICO_DBG("hide (no last) %s", win_info->appid);
 772             ico_syc_hide(win_info->appid, win_info->surface, &animation);
 773         }
 774     }
 775     ICO_TRA("CicoHomeScreen::ShowApplicationWindow Leave");
 776 }
 777
 778 /*--------------------------------------------------------------------------*/
 779 /**
 780  * @brief   CicoHomeScreen::RaiseApplicationWindow
 781  *          raise window (application)
 782  *
 783  * @param[in]   appid      application id
 784  * @param[in]   surface    surface
 785  * @return      none
 786  */
 787 /*--------------------------------------------------------------------------*/
 788 void
 789 CicoHomeScreen::RaiseApplicationWindow(const char *appid,int surface)
 790 {
 791     ico_syc_show(appid, surface, NULL);
 792     ico_syc_change_active(appid, surface);
 793     hs_instance->SetActiveAppInfo(appid);
 794 }
 795
 796 /*--------------------------------------------------------------------------*/
 797 /**
 798  * @brief   CicoHomeScreen::EventCallBack
 799  *          callback for system controller
 800  *
 801  * @param[in]   event      kind of event
 802  * @param[in]   detail     detail
 803  * @param[in]   user_data  user data
 804  * @return      none
 805  */
 806 /*--------------------------------------------------------------------------*/
 807 void
 808 CicoHomeScreen::EventCallBack(const ico_syc_ev_e event,
 809                               const void *detail,void *user_data)
 810 {
 811     int     idx;
 812
 813 //    ICO_DBG("CicoHomeScreen::EventCallBack: start (event %d)",event);
 814
 815     if (event == ICO_SYC_EV_WIN_CREATE) {
 816         ico_syc_win_info_t *win_info =
 817             reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
 818         ICO_DBG("Event:ICO_SYC_EV_WIN_CREATE(appid=%s surface=%08x)",
 819                 win_info->appid, win_info->surface);
 820         /*only save information*/
 821         if (strncmp(win_info->appid, hs_instance->GetHsPackageName(),
 822                     ICO_HS_MAX_PROCESS_NAME) == 0)  {
 823             /*Home Screen*/
 824             hs_instance->hs_app_info->AddWindowInfo(win_info);
 825
 826             /*when Menu window*/
 827             if (strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
 828                         ICO_MAX_TITLE_NAME_LEN) == 0) {
 829                 hs_instance->menu_window->SetMenuWindowID(win_info->appid,
 830                                                           win_info->surface);
 831             }
 832             else if (strncmp(win_info->name,ICO_HS_CONTROL_BAR_WINDOW_TITLE,
 833                              ICO_MAX_TITLE_NAME_LEN) == 0) {
 834                 hs_instance->ctl_bar_window->SetWindowID(win_info->appid,
 835                                                          win_info->surface);
 836             }
 837             else    {
 838                 if (win_info->name[0] == 0) {
 839                   /* null name, nothing to do */
 840                     return;
 841                 }
 842                 for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++)    {
 843                     if (hs_instance->swipe_input_windows[idx]->
 844                                          isMyWindowName(win_info->name)) {
 845                         hs_instance->swipe_input_windows[idx]->
 846                                          SetWindowID(win_info->appid, win_info->surface);
 847                         hs_instance->swipe_input_windows[idx]->SetupSwipeWindow();
 848                         break;
 849                     }
 850                 }
 851             }
 852             /*show window*/
 853             hs_instance->ShowHomeScreenWindow(win_info);
 854         }
 855         else if (strncmp(win_info->appid,
 856                          hs_instance->GetSbPackageName(),
 857                          ICO_HS_MAX_PROCESS_NAME) == 0) {
 858             /*Status Bar*/
 859             hs_instance->sb_app_info->AddWindowInfo(win_info);
 860
 861             /*show window*/
 862             hs_instance->ShowStatusBarWindow(win_info);
 863         }
 864         else if (strncmp(win_info->appid,
 865                          hs_instance->GetOsPackageName(),
 866                          ICO_HS_MAX_PROCESS_NAME) == 0) {
 867
 868             // On Screen
 869             hs_instance->os_app_info->AddWindowInfo(win_info);
 870
 871             // change the layer of onscreen window
 872             ico_syc_change_layer(win_info->appid, win_info->surface,
 873                                  HS_LAYER_ONSCREEN);
 874
 875             const CicoSCPositionOSConf* oPOSC =
 876                 CicoSystemConfig::getInstance()->positionOSConf();
 877             ico_syc_win_move_t move;
 878             move.zone   = NULL;
 879             move.layer  = HS_LAYER_ONSCREEN;
 880             move.pos_x  = oPOSC->m_x;
 881             move.pos_y  = oPOSC->m_y;
 882             move.width  = oPOSC->m_w;
 883             move.height = oPOSC->m_h;
 884             ico_syc_animation_t animation;
 885             animation.name = (char*)ICO_HS_MENU_SHOW_ANIMATION_SLIDE;
 886             animation.time = ICO_HS_MENU_ANIMATION_DURATION;
 887             ico_syc_move(win_info->appid, win_info->surface, &move, &animation);
 888
 889         }
 890         else    {
 891             /*Application*/
 892             CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(win_info->appid);
 893             if (appinfo == NULL) {
 894                 return;
 895             }
 896             appinfo->AddWindowInfo(win_info);
 897
 898             appinfo->SetLastSurface(win_info->surface);
 899             hs_instance->ShowApplicationWindow(win_info);
 900             ico_syc_change_active(win_info->appid,win_info->surface);
 901             hs_instance->SetActiveAppInfo(win_info->appid);
 902             hs_instance->UpdateTile(win_info->appid);
 903
 904             hs_instance->startupCheck(win_info->appid);
 905         }
 906     }
 907     else if (event == ICO_SYC_EV_WIN_NAME) {
 908         ico_syc_win_info_t *win_info =
 909             reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
 910         ICO_DBG("Event:ICO_SYC_EV_WIN_NAME(appid=%s surface=%08x name=%s)",
 911                 win_info->appid, win_info->surface, win_info->name);
 912
 913         if (strncmp(win_info->appid, hs_instance->GetHsPackageName(),
 914                     ICO_HS_MAX_PROCESS_NAME) == 0) {
 915             /*Home Screen*/
 916             hs_instance->hs_app_info->AddWindowInfo(win_info);
 917
 918             /*when Menu window*/
 919             if (strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
 920                         ICO_MAX_TITLE_NAME_LEN) == 0) {
 921                 hs_instance->menu_window->SetMenuWindowID(win_info->appid,
 922                                                           win_info->surface);
 923             }
 924             else if (strncmp(win_info->name,ICO_HS_CONTROL_BAR_WINDOW_TITLE,
 925                              ICO_MAX_TITLE_NAME_LEN) == 0) {
 926                 hs_instance->ctl_bar_window->SetWindowID(win_info->appid,
 927                                                          win_info->surface);
 928             }
 929             else    {
 930                 for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++)    {
 931                     if (hs_instance->swipe_input_windows[idx]->
 932                                          isMyWindowName(win_info->name)) {
 933                         hs_instance->swipe_input_windows[idx]->
 934                                          SetWindowID(win_info->appid, win_info->surface);
 935                         hs_instance->swipe_input_windows[idx]->SetupSwipeWindow();
 936                         break;
 937                     }
 938                 }
 939             }
 940
 941             /*show window*/
 942             hs_instance->ShowHomeScreenWindow(win_info);
 943         }
 944         else if (strncmp(win_info->appid, hs_instance->GetSbPackageName(),
 945                          ICO_HS_MAX_PROCESS_NAME) == 0) {
 946             /*Status Bar*/
 947             hs_instance->sb_app_info->AddWindowInfo(win_info);
 948         }
 949         else if (strncmp(win_info->appid, hs_instance->GetOsPackageName(),
 950                          ICO_HS_MAX_PROCESS_NAME) == 0) {
 951             /*On Screen*/
 952             hs_instance->os_app_info->AddWindowInfo(win_info);
 953         }
 954         else {
 955             /*Application*/
 956             CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(win_info->appid);
 957             if (appinfo == NULL) {
 958                 return;
 959             }
 960             appinfo->AddWindowInfo(win_info);
 961         }
 962     }
 963     else if (event == ICO_SYC_EV_WIN_DESTROY) {
 964         ico_syc_win_info_t *win_info =
 965             reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
 966         ICO_DBG("Event:ICO_SYC_EV_WIN_DESTROY(appid=%s surface=%08x)",
 967                 win_info->appid, win_info->surface);
 968         /*only save information*/
 969         if (strncmp(win_info->appid, hs_instance->GetHsPackageName(),
 970                     ICO_HS_MAX_PROCESS_NAME) == 0)  {
 971             hs_instance->hs_app_info->FreeWindowInfo(win_info->name);
 972         }
 973         else if (strncmp(win_info->appid,
 974                          hs_instance->GetSbPackageName(),
 975                          ICO_HS_MAX_PROCESS_NAME) == 0) {
 976             hs_instance->sb_app_info->FreeWindowInfo(win_info->name);
 977         }
 978         else if (strncmp(win_info->appid,
 979                          hs_instance->GetOsPackageName(),
 980                          ICO_HS_MAX_PROCESS_NAME) == 0) {
 981             hs_instance->os_app_info->FreeWindowInfo(win_info->name);
 982         }
 983         else    {
 984             /*Application*/
 985             CicoHSAppInfo *appinfo =
 986                        hs_instance->GetAppInfo(win_info->appid);
 987             if (appinfo == NULL) {
 988                 return;
 989             }
 990             appinfo->FreeWindowInfo(win_info->surface);
 991             hs_instance->UpdateTile(win_info->appid);
 992
 993             // update active application information
 994             CicoHSAppInfo *active_appinfo = hs_instance->GetActiveAppInfo();
 995             if (appinfo == active_appinfo) {
 996                 hs_instance->SetActiveAppInfo(NULL);
 997             }
 998
 999             // update sub displayed application information
1000             CicoHSAppInfo *subdisp_appinfo = hs_instance->GetSubDisplayAppInfo();
1001             if (appinfo == subdisp_appinfo) {
1002                 hs_instance->SetSubDisplayAppInfo(NULL);
1003             }
1004         }
1005     }
1006     else if (event == ICO_SYC_EV_WIN_ACTIVE) {
1007         ico_syc_win_info_t *win_info =
1008             reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
1009         ICO_DBG("Event:ICO_SYC_EV_WIN_ACTIVE(appid=%s surface=%08x)",
1010                 win_info->appid, win_info->surface);
1011         hs_instance->ChangeActive(win_info->appid, win_info->surface);
1012     }
1013     else if (event == ICO_SYC_EV_WIN_ATTR_CHANGE)   {
1014         ico_syc_win_attr_t *win_attr =
1015             reinterpret_cast<ico_syc_win_attr_t*>(const_cast<void*>(detail));
1016         ICO_DBG("Event:ICO_SYC_EV_WIN_ATTR_CHANGE(appid=%s surface=%08x)",
1017                 win_attr->appid, win_attr->surface);
1018         if (strncmp(win_attr->appid, hs_instance->GetHsPackageName(),
1019                     ICO_HS_MAX_PROCESS_NAME) == 0)  {
1020             /*Home Screen*/
1021             hs_instance->hs_app_info->AddWindowAttr(win_attr);
1022         }
1023         else if (strncmp(win_attr->appid, hs_instance->GetSbPackageName(),
1024                          ICO_HS_MAX_PROCESS_NAME) == 0) {
1025             /*Status Bar*/
1026             hs_instance->sb_app_info->AddWindowAttr(win_attr);
1027         }
1028         else if (strncmp(win_attr->appid, hs_instance->GetOsPackageName(),
1029                          ICO_HS_MAX_PROCESS_NAME) == 0) {
1030             /*On Screen*/
1031             hs_instance->os_app_info->AddWindowAttr(win_attr);
1032         }
1033         else {
1034             ICO_DBG("CicoHomeScreen::EventCallBack : application window %s %s",
1035                     win_attr->appid,win_attr->name);
1036             /*Application*/
1037             CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(win_attr->appid);
1038             if (appinfo == NULL) {
1039                 return;
1040             }
1041
1042             // change layer when moved zone in second display
1043             ico_hs_window_info *winfo = NULL;
1044             winfo = appinfo->GetWindowInfobySurface(win_attr->surface);
1045             if (NULL != winfo) {
1046                 if (win_attr->nodeid != winfo->nodeid) {
1047                     if (0 == win_attr->nodeid) {
1048                         if (NULL != hs_instance->GetSubDisplayAppInfo()) {
1049                             if (hs_instance->m_appHis) {
1050                                 const string& wapp = hs_instance->m_appHis->getSelectApp();
1051                                 ICO_DBG("\"%s\"->\"%s\"", wapp.c_str(), winfo->appid);
1052                                 if ((false == wapp.empty()) &&
1053                                     (0 != wapp.compare(winfo->appid))) {
1054                                     hs_instance->requestHideAppid(wapp);
1055                                     hs_instance->m_appHis->clearSelectApp();
1056                                     hs_instance->m_appHis->homeSwipe();
1057                                 }
1058                             }
1059                             ICO_DBG("reset sub display");
1060                             hs_instance->SetSubDisplayAppInfo(NULL);
1061                             hs_instance->ChangeActive(winfo->appid, winfo->surface);
1062                         }
1063                     }
1064                     else {
1065                         ICO_DBG("set sub display");
1066                         hs_instance->SetSubDisplayAppInfo(winfo->appid);
1067                     }
1068
1069                     if (hs_instance->m_appHis) {
1070                         if (true == hs_instance->m_appHis->chgChk()) {
1071                             hs_instance->m_appHis->writeAppHistory();
1072                         }
1073                         hs_instance->m_appHis->homeSwipe();
1074                     }
1075                 }
1076             }
1077
1078             // update window information
1079             appinfo->AddWindowAttr(win_attr);
1080             hs_instance->UpdateTile(win_attr->appid);
1081         }
1082     }
1083     else if (event == ICO_SYC_EV_THUMB_CHANGE)  {
1084         ico_syc_thumb_info_t *thumb_info =
1085             reinterpret_cast<ico_syc_thumb_info_t*>(const_cast<void*>(detail));
1086         CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(thumb_info->appid);
1087         if (appinfo == NULL)    {
1088             ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_CHANGE %s(%02x) "
1089                     "no appinfo", thumb_info->appid, thumb_info->surface);
1090             return;
1091         }
1092 //      ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_CHANGE %s(%02x)",
1093 //              thumb_info->appid, thumb_info->surface);
1094         // show thumbnail icon
1095         hs_instance->menu_window->SetThumbnail(thumb_info->appid, thumb_info);
1096     }
1097     else if (event == ICO_SYC_EV_THUMB_UNMAP)  {
1098         ico_syc_thumb_info_t *thumb_info =
1099             reinterpret_cast<ico_syc_thumb_info_t*>(const_cast<void*>(detail));
1100         CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(thumb_info->appid);
1101         if (appinfo == NULL)    {
1102             ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_UNMAP %s(%02x) "
1103                     "no appinfo", thumb_info->appid, thumb_info->surface);
1104             return;
1105         }
1106         ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_UNMAP %s(%02x)",
1107                 thumb_info->appid, thumb_info->surface);
1108         hs_instance->menu_window->SetThumbnail(thumb_info->appid, NULL);
1109     }
1110     else if (event == ICO_SYC_EV_THUMB_ERROR)  {
1111         ico_syc_thumb_info_t *thumb_info =
1112             reinterpret_cast<ico_syc_thumb_info_t*>(const_cast<void*>(detail));
1113         CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(thumb_info->appid);
1114         if (appinfo == NULL)    {
1115             ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_ERROR %s(%02x) "
1116                     "no appinfo", thumb_info->appid, thumb_info->surface);
1117             return;
1118         }
1119         ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_ERROR %s(%02x)",
1120                 thumb_info->appid, thumb_info->surface);
1121         hs_instance->menu_window->SetThumbnail(thumb_info->appid, NULL);
1122     }
1123     else if (event == ICO_SYC_EV_LAYER_ATTR_CHANGE) {
1124
1125     }
1126     else if (event == ICO_SYC_EV_USERLIST)  {
1127
1128     }
1129     else if (event == ICO_SYC_EV_AUTH_FAIL) {
1130
1131     }
1132     else if (event == ICO_SYC_EV_RES_ACQUIRE) {
1133
1134     }
1135     else if (event == ICO_SYC_EV_RES_DEPRIVE)   {
1136
1137     }
1138     else if (event == ICO_SYC_EV_RES_WAITING)   {
1139
1140     }
1141     else if (event == ICO_SYC_EV_RES_REVERT)    {
1142
1143     }
1144     else if (event == ICO_SYC_EV_RES_RELEASE)   {
1145
1146     }
1147     else if (event == ICO_SYC_EV_INPUT_SET) {
1148
1149     }
1150     else if (event == ICO_SYC_EV_INPUT_UNSET)   {
1151
1152     }
1153     else if (event == ICO_SYC_EV_STATE_CHANGE)  {
1154         ico_syc_state_info_t *state_info =
1155             reinterpret_cast<ico_syc_state_info_t*>(const_cast<void*>(detail));
1156         ICO_DBG("EVENT:ICO_SYC_EV_STATE_CHANGE(id=%d state=%d)",
1157                 state_info->id, state_info->state);
1158         if (ICO_SYC_STATE_REGULATION == state_info->id) {
1159             // set regulation state
1160             CicoHSSystemState::getInstance()->setRegulation(
1161                 (state_info->state == ICO_SYC_STATE_ON) ? true : false);
1162             ecore_main_loop_thread_safe_call_async(CicoHomeScreen::SetRegulation, NULL);
1163         }
1164         else if (ICO_SYC_STATE_NIGHTMODE == state_info->id) {
1165             // set night mode state
1166             CicoHSSystemState::getInstance()->setNightMode(
1167                 (state_info->state == ICO_SYC_STATE_ON) ? true : false);
1168             ecore_main_loop_thread_safe_call_async(CicoHomeScreen::SetNightMode, NULL);
1169         }
1170     }
1171 //    ICO_DBG("CicoHomeScreen::EventCallBack: end");
1172 }
1173
1174 /*--------------------------------------------------------------------------*/
1175 /**
1176  * @brief   CicoHomeScreen::StartRelations
1177  *          Execute Onscreen and Statusbar
1178  *
1179  * @param[in]   none
1180  * @return      OK
1181  */
1182 /*--------------------------------------------------------------------------*/
1183 int
1184 CicoHomeScreen::StartRelations(void)
1185 {
1186     int ret;
1187     strncpy(sb_package_name,
1188             (char *)config->ConfigGetString(ICO_HS_CONFIG_HOMESCREEN,
1189                                              ICO_HS_CONFIG_SB,
1190                                              ICO_HS_APPID_DEFAULT_SB),
1191             ICO_HS_MAX_PROCESS_NAME);
1192     strncpy(os_package_name,
1193              (char *)config->ConfigGetString(ICO_HS_CONFIG_HOMESCREEN,
1194                                              ICO_HS_CONFIG_ONS,
1195                                              ICO_HS_APPID_DEFAULT_ONS),
1196             ICO_HS_MAX_PROCESS_NAME);
1197 // TODO
1198 #if 1   /* ToDo     */
1199     /* start onscreen & statusbar apps */
1200     os_app_info = GetAppInfo(os_package_name);
1201     ret = os_app_info->Execute();
1202     if (ret < 0) {
1203         ICO_WRN("execute failed(%s) err=%d", os_package_name, ret);
1204     }
1205 #endif
1206
1207     sb_app_info = GetAppInfo(sb_package_name);
1208     ret = sb_app_info->Execute();
1209     if (ret < 0) {
1210         ICO_WRN("execute failed(%s) err=%d", sb_package_name, ret);
1211     }
1212     return ICO_OK;
1213 }
1214
1215 /*--------------------------------------------------------------------------*/
1216 /**
1217  * @brief   CicoHomeScreen::Initialize
1218  *          Initialize
1219  *
1220  * @param[in]   orientation    vertical or horizontal
1221  * @param[in]   config         config
1222  * @return      OK or ERROR
1223  */
1224 /*--------------------------------------------------------------------------*/
1225 int
1226 CicoHomeScreen::Initialize(int orientation, CicoGKeyFileConfig *config)
1227 {
1228
1229     ICO_DBG("CicoHomeScreen::Initialize: start");
1230     /*save instance pointer */
1231     hs_instance = this;
1232
1233     /*config copy*/
1234     this->config = new CicoGKeyFileConfig();
1235     this->config->Initialize(ICO_HOMESCREEN_CONFIG_FILE);
1236
1237     /*Get application info*/
1238     CreateAppInfoList();
1239
1240     /* get pkg name (home screen,status bar,on screen)*/
1241     char *pkg;
1242     ICO_DBG("CicoHomeSceen::Initialize: %s: %s",
1243             getenv("HOME"), getenv("PKG_NAME"));
1244     pkg = getenv("PKG_NAME");
1245     memset(hs_package_name, 0, ICO_HS_MAX_PROCESS_NAME);
1246     if (pkg)    {
1247         strncpy(hs_package_name, pkg, ICO_HS_MAX_PROCESS_NAME);
1248     }
1249     else    {
1250         strncpy(hs_package_name, ICO_HS_PROC_DEFAULT_HOMESCREEN,
1251                 ICO_HS_MAX_PROCESS_NAME);
1252     }
1253
1254     /* Initialize WindowController */
1255     CicoHSWindowController::Initialize();
1256     ICO_DBG("CicoHomeScreen::Initialize: window controller initialized");
1257
1258     ICO_DBG("CicoHomeScreen::Initialize: start connect to systemcontroller");
1259     ico_syc_connect(EventCallBack,NULL);
1260     ICO_DBG("CicoHomeScreen::Initialize: end connect to systemcontroller");
1261
1262     /*initialize system controller*/
1263     /*my info*/
1264     ICO_DBG("CicoHomeScreen::Initialize: get package name %s",hs_package_name);
1265     hs_app_info = GetAppInfo(hs_package_name);
1266
1267     /*start home statusbar and onscreen*/
1268     StartRelations();
1269     ICO_DBG("CicoHomeScreen::Initialize: start relation apps");
1270
1271     /* Get screen size */
1272     CicoHSWindowController::GetFullScreenSize(orientation,
1273                                               &full_width,&full_height);
1274
1275     ICO_DBG("full screen size x=%d y=%d",full_width,full_height);
1276
1277     /* MenuScreen Window Size */
1278     menu_width = full_width;
1279     menu_height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
1280                   ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1281
1282     /* BackGround Window Size */
1283     bg_width = full_width;
1284     bg_height = full_height;
1285
1286     /* Control Bar Window Size */
1287     ctl_bar_width = full_width;
1288     ctl_bar_height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1289
1290     // load switch display zone config
1291     moveZoneName = config->ConfigGetString("switchzone", "movezone", NULL);
1292
1293     moveZoneAnimation.name = (char*)config->ConfigGetString("switchzone",
1294                                                             "animation",
1295                                                             ICO_HS_ANIMATION_FADE);
1296
1297     moveZoneAnimation.time = config->ConfigGetInteger("switchzone",
1298                                                       "animatime", 400);
1299
1300     // debug log
1301     ICO_DBG("moveZoneName=%s animation=%s time=%d",
1302             moveZoneName, moveZoneAnimation.name, moveZoneAnimation.time);
1303
1304     ICO_DBG("CicoHomeScreen::Initialize: end");
1305
1306     return ICO_OK;
1307 }
1308
1309 /*--------------------------------------------------------------------------*/
1310 /**
1311  * @brief   CicoHomeScreen::InitializeAppHistory
1312  *          Initialize application History Manager
1313  */
1314 /*--------------------------------------------------------------------------*/
1315 void
1316 CicoHomeScreen::InitializeAppHistory(void)
1317 {
1318     ICO_DBG("start");
1319     if (NULL != m_appHis) {
1320         ICO_DBG("end");
1321         return;
1322     }
1323     CicoHSCmdOpts* cmdOpts = CicoHSCmdOpts::getInstance();
1324     m_appHis = new CicoHSAppHistoryExt(cmdOpts->getLoginUser(),
1325                                        cmdOpts->getHistoryFilePath(),
1326                                        cmdOpts->getDefaultHistoryFilePath(),
1327                                        cmdOpts->getFlagPath());
1328     m_appHis->force_flagoff();
1329     m_appHis->setHomeScreen(this);
1330
1331     const char* val;
1332     val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1333                                   ICO_HS_CONFIG_HSTRY_KEY1,
1334                                   ICO_HS_CONFIG_HSTRY_DEF1);
1335     ICO_DBG("timer = %s", val);
1336     double dV = atof(val);
1337     m_appHis->setWaitTime(dV);
1338
1339     val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1340                                   ICO_HS_CONFIG_HSTRY_KEY2,
1341                                   ICO_HS_CONFIG_HSTRY_DEF2);
1342     vector<string> vvM;
1343     if ((NULL != val) && (0 != val) && (0 != strlen(val))) {
1344         string tmpM(val);
1345         split(tmpM, ICO_HS_CONFIG_HSTRY_SPL, vvM);
1346     }
1347     if (0 != vvM.size()) {
1348         ICO_DBG("manage off = %s split=%d", val, (int)vvM.size());
1349         m_appHis->setFilterManage(vvM);
1350     }
1351     val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1352                                   ICO_HS_CONFIG_HSTRY_KEY3,
1353                                   ICO_HS_CONFIG_HSTRY_DEF3);
1354     vector<string> vvW;
1355     if ((NULL != val) && (0 != val) && (0 != strlen(val))) {
1356         string tmpW(val);
1357         split(tmpW, ICO_HS_CONFIG_HSTRY_SPL, vvW);
1358     }
1359     if (0 != vvW.size()) {
1360         ICO_DBG("write off = %s, split=%d", val, (int)vvW.size());
1361         m_appHis->setFilterWrite(vvW);
1362     }
1363     ICO_DBG("end");
1364 }
1365
1366 /*--------------------------------------------------------------------------*/
1367 /**
1368  * @brief   CicoHomeScreen::Finalize
1369  *          Finalize
1370  *
1371  * @param[in]   none
1372  * @return      none
1373  */
1374 /*--------------------------------------------------------------------------*/
1375 void
1376 CicoHomeScreen::Finalize(void)
1377 {
1378     /* Finalize WindowController */
1379     CicoHSWindowController::Finalize();
1380
1381     ico_syc_disconnect();
1382
1383     delete hs_app_info;
1384 }
1385
1386 /*--------------------------------------------------------------------------*/
1387 /**
1388  * @brief   CicoHomeScreen::CreateMenuWindow
1389  *          create menu window
1390  *
1391  * @param[in]   none
1392  * @return      none
1393  */
1394 /*--------------------------------------------------------------------------*/
1395 void
1396 CicoHomeScreen::CreateMenuWindow(void)
1397 {
1398     /*create window*/
1399     ICO_DBG("CicoHomeScreen::CreateMenuWindow: start");
1400     menu_window = new CicoHSMenuWindow();
1401     menu_window->CreateMenuWindow(ICO_HS_WINDOW_POS_X,ICO_HS_WINDOW_POS_Y,
1402                                   menu_width,menu_height);
1403     menu_window->ShowWindow();
1404     ICO_DBG("CicoHomeScreen::CreateMenuWindow: end");
1405 }
1406
1407 /*--------------------------------------------------------------------------*/
1408 /**
1409  * @brief   CicoHomeScreen::DeleteMenuWindow
1410  *          delete menu window
1411  *
1412  * @param[in]   none
1413  * @return      none
1414  */
1415 /*--------------------------------------------------------------------------*/
1416 void
1417 CicoHomeScreen::DeleteMenuWindow(void)
1418 {
1419     if (menu_window == NULL)    {
1420         return;
1421     }
1422     menu_window->FreeMenuWindow();
1423     delete menu_window;
1424
1425 }
1426
1427 /*--------------------------------------------------------------------------*/
1428 /**
1429  * @brief   CicoHomeScreen::UpdateMenuWindow
1430  *          update menu window
1431  *
1432  * @param[in]   none
1433  * @return      none
1434  */
1435 /*--------------------------------------------------------------------------*/
1436 void
1437 CicoHomeScreen::UpDateMenuWindow(void)
1438 {
1439     DeleteMenuWindow();
1440     CreateMenuWindow();
1441 }
1442
1443 /*--------------------------------------------------------------------------*/
1444 /**
1445  * @brief   CicoHomeScreen::CreateBackWindow
1446  *          create back window
1447  *
1448  * @param[in]   none
1449  * @return      none
1450  */
1451 /*--------------------------------------------------------------------------*/
1452 void
1453 CicoHomeScreen::CreateBackWindow(void)
1454 {
1455     /*create window*/
1456     ICO_DBG("CicoHomeScreen::CreateBackWindow");
1457     back_window = new CicoHSBackWindow();
1458     back_window->CreateBackWindow(ICO_HS_WINDOW_POS_X,ICO_HS_WINDOW_POS_Y,
1459                                   bg_width,bg_height);
1460     back_window->ShowWindow();
1461 }
1462
1463 /*--------------------------------------------------------------------------*/
1464 /**
1465  * @brief   CicoHomeScreen::CreateBackWindow
1466  *          create back window
1467  *
1468  * @param[in]   none
1469  * @return      none
1470  */
1471 /*--------------------------------------------------------------------------*/
1472 void
1473 CicoHomeScreen::DeleteBackWindow(void)
1474 {
1475     if (back_window == NULL)    {
1476         return;
1477     }
1478     back_window->FreeBackWindow();
1479     delete back_window;
1480 }
1481
1482 /*--------------------------------------------------------------------------*/
1483 /**
1484  * @brief   CicoHomeScreen::UpDateBackWindow
1485  *          update back window
1486  *
1487  * @param[in]   none
1488  * @return      none
1489  */
1490 /*--------------------------------------------------------------------------*/
1491 void
1492 CicoHomeScreen::UpDateBackWindow(void)
1493 {
1494     DeleteBackWindow();
1495     CreateBackWindow();
1496 }
1497
1498 /*--------------------------------------------------------------------------*/
1499 /**
1500  * @brief   CicoHomeScreen::CreateControlBarWindow
1501  *          create control bar window
1502  *
1503  * @param[in]   none
1504  * @return      none
1505  */
1506 /*--------------------------------------------------------------------------*/
1507 void
1508 CicoHomeScreen::CreateControlBarWindow(void)
1509 {
1510     /*create window*/
1511     ICO_DBG("CicoHomeScreen::CreateControlBarWindow");
1512     ctl_bar_window = new CicoHSControlBarWindow();
1513     ctl_bar_window->CreateControlBarWindow(ICO_HS_MENU_WINDOW_POS_X,bg_height -
1514                                            ctl_bar_height,ctl_bar_width,
1515                                            ctl_bar_height);
1516     ctl_bar_window->ShowWindow();
1517 }
1518
1519 /*--------------------------------------------------------------------------*/
1520 /**
1521  * @brief   CicoHomeScreen::DeleteControlBarWindow
1522  *          delete control bar window
1523  *
1524  * @param[in]   none
1525  * @return      none
1526  */
1527 /*--------------------------------------------------------------------------*/
1528 void
1529 CicoHomeScreen::DeleteControlBarWindow(void)
1530 {
1531     if (ctl_bar_window == NULL) {
1532         return;
1533     }
1534     ctl_bar_window->FreeControlBarWindow();
1535     delete ctl_bar_window;
1536 }
1537
1538 /*--------------------------------------------------------------------------*/
1539 /**
1540  * @brief   CicoHomeScreen::CreateSwipeInputWindow
1541  *          create swipe input windows
1542  *
1543  * @param[in]   none
1544  * @return      none
1545  */
1546 /*--------------------------------------------------------------------------*/
1547 void
1548 CicoHomeScreen::CreateSwipeInputWindow(void)
1549 {
1550     int     pos_y, swipe_height;
1551
1552     ICO_DBG("CicoHomeScreen::CreateSwipeInputWindow: start");
1553     /* cullentry SwipeInput windows is fixed size   */
1554     pos_y = ICO_HS_WINDOW_POS_Y + ICO_HS_SWIPE_TOUCH_DISTANCE_TOP;
1555     swipe_height = full_height - pos_y - ICO_HS_SWIPE_TOUCH_DISTANCE_BOTTOM;
1556
1557     /* left side window     */
1558     swipe_input_windows[0] = new CicoHSSwipeInputWindow();
1559     swipe_input_windows[0]->
1560             CreateSwipeInputWindow(ICO_HS_WINDOW_POS_X, pos_y,
1561                                    ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, swipe_height,
1562                                    "left");
1563     swipe_input_windows[0]->ShowWindow();
1564
1565     /* right side window    */
1566     swipe_input_windows[1] = new CicoHSSwipeInputWindow();
1567     swipe_input_windows[1]->
1568             CreateSwipeInputWindow(full_width - ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, pos_y,
1569                                    ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, swipe_height,
1570                                    "right");
1571     swipe_input_windows[1]->ShowWindow();
1572
1573 #if 0       /* currently not support(not fix specification) */
1574     /* buttom side window   */
1575     swipe_input_windows[2] = new CicoHSSwipeInputWindow();
1576     swipe_input_windows[2]->
1577             CreateSwipeInputWindow(ICO_HS_WINDOW_POS_X,
1578                                    full_height - ICO_HS_SWIPE_TOUCH_SWIPE_HEIGHT,
1579                                    full_width, ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, "buttom");
1580
1581     swipe_input_windows[2]->ShowWindow();
1582     num_swipe_input_windows = 3;
1583 #else
1584     num_swipe_input_windows = 2;
1585 #endif
1586     ICO_DBG("CicoHomeScreen::CreateSwipeInputWindow: end");
1587 }
1588
1589 /*--------------------------------------------------------------------------*/
1590 /**
1591  * @brief   CicoHomeScreen::DeleteSwipeInputWindow
1592  *          delete swipe input windows
1593  *
1594  * @param[in]   none
1595  * @return      none
1596  */
1597 /*--------------------------------------------------------------------------*/
1598 void
1599 CicoHomeScreen::DeleteSwipeInputWindow(void)
1600 {
1601     int idx;
1602
1603     for (idx = 0; idx < num_swipe_input_windows; idx++) {
1604         if (swipe_input_windows[idx])   {
1605             swipe_input_windows[idx]->FreeSwipeInputWindow();
1606             delete swipe_input_windows[idx];
1607             swipe_input_windows[idx] = NULL;
1608         }
1609     }
1610     num_swipe_input_windows = 0;
1611 }
1612
1613 /*--------------------------------------------------------------------------*/
1614 /**
1615  * @brief   launch applications
1616  *
1617  * @param   filepath  start applications list file path
1618  * @param   filepathD defalt start applications list file path
1619  * @return  bool
1620  * @retval  true  success
1621  * @retval  false fail
1622  */
1623 /*--------------------------------------------------------------------------*/
1624 static Eina_Bool launchApps(void* data)
1625 {
1626     ICO_DBG("start");
1627     launcApps_data_t* x = (launcApps_data_t*) data;
1628     if ((NULL == x) || (NULL == x->hs)) {
1629         ICO_DBG("end fail");
1630         return ECORE_CALLBACK_CANCEL;
1631     }
1632
1633     vector<pairAppidSubd> apps;
1634     x->hs->readStartupApp(apps);
1635
1636     int sz = apps.size();
1637     for (int i =sz; i > 0; i--) {
1638         string appid = apps[i-1].first;
1639         bool bFLAG = apps[i-1].second;
1640         const char* app = appid.c_str();
1641         ICO_PRF("CHG_APP_STA 1.request app=%s", app);
1642         int pid = aul_launch_app(appid.c_str(), NULL);
1643         ICO_DBG("            1.request [%d]%d:%s:%d", i, pid, app, (int)bFLAG);
1644         if ((0 < pid) && (NULL != x->hs)) {
1645             x->hs->startupCheckAdd(pid, appid, bFLAG);
1646         }
1647     }
1648     ICO_DBG("end success");
1649     return ECORE_CALLBACK_CANCEL;
1650 }
1651
1652 /*--------------------------------------------------------------------------*/
1653 /**
1654  * @brief   CicoHomeScreen::StartHomeScreen
1655  *          start home screen
1656  *
1657  * @param[in]   none
1658  * @return      none
1659  */
1660 /*--------------------------------------------------------------------------*/
1661 int
1662 CicoHomeScreen::StartHomeScreen(int orientation)
1663 {
1664     int     retry;
1665
1666     ICO_TRA("CicoHomeScreen::StartHomeScreen Enter");
1667
1668     /*save instance pointer */
1669     hs_instance = this;
1670
1671     /*config copy*/
1672     this->config = new CicoGKeyFileConfig();
1673     this->config->Initialize(ICO_HOMESCREEN_CONFIG_FILE);
1674
1675     /* init home screen soud */
1676     CicoSound::GetInstance()->Initialize(this->config);
1677
1678     /*Get application info*/
1679     CreateAppInfoList();
1680
1681     /* get pkg name (home screen,status bar,on screen)*/
1682     char *pkg;
1683     ICO_DBG("CicoHomeSceen::StartHomeScreen: %s: %s",
1684             getenv("HOME"), getenv("PKG_NAME"));
1685     pkg = getenv("PKG_NAME");
1686     memset(hs_package_name, 0, ICO_HS_MAX_PROCESS_NAME);
1687     if (pkg)    {
1688         strncpy(hs_package_name, pkg, ICO_HS_MAX_PROCESS_NAME);
1689     }
1690     else    {
1691         strncpy(hs_package_name, ICO_HS_PROC_DEFAULT_HOMESCREEN,
1692                 ICO_HS_MAX_PROCESS_NAME);
1693     }
1694
1695     /* create application control instance */
1696     CicoHSAppControl *m_appctrl = CicoHSAppControl::getInstance();
1697
1698     /* create server instance */
1699     CicoHSServer *server = CicoHSServer::getInstance();
1700     server->setAppCtrl(m_appctrl);
1701     server->startup(10001, (const char*)"ico_hs_protocol");
1702
1703     /* Initialize WindowController */
1704     CicoHSWindowController::Initialize();
1705     ICO_DBG("CicoHomeScreen::StartHomeScreen: window controller initialized");
1706
1707     ICO_DBG("CicoHomeScreen::StartHomeScreen: start connect to systemcontroller");
1708     ico_syc_connect(EventCallBack,NULL);
1709     for (retry = 0; retry < (2000/10); retry++) {
1710         ico_syc_service();
1711         if (ico_syc_isconnect())    break;
1712         usleep(10*1000);
1713     }
1714     ICO_DBG("CicoHomeScreen::StartHomeScreen: end connect to systemcontroller");
1715
1716     /*initialize system controller*/
1717     /*my info*/
1718     ICO_DBG("CicoHomeScreen::StartHomeScreen: get package name %s",hs_package_name);
1719     hs_app_info = GetAppInfo(hs_package_name);
1720
1721     /*start home statusbar and onscreen*/
1722     StartRelations();
1723     ICO_DBG("CicoHomeScreen::StartHomeScreen: start relation apps");
1724
1725     /* Get screen size */
1726     CicoHSWindowController::GetFullScreenSize(orientation,
1727                                               &full_width,&full_height);
1728
1729     ICO_DBG("full screen size x=%d y=%d",full_width,full_height);
1730
1731     /* MenuScreen Window Size */
1732     menu_width = full_width;
1733     menu_height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
1734                   ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1735
1736     /* BackGround Window Size */
1737     bg_width  = full_width;
1738     bg_height = full_height;
1739
1740     /* Control Bar Window Size */
1741     ctl_bar_width  = full_width;
1742     ctl_bar_height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1743
1744     // load switch display zone config
1745     moveZoneName = config->ConfigGetString("switchzone", "movezone", NULL);
1746
1747     moveZoneAnimation.name = (char*)config->ConfigGetString("switchzone",
1748                                                             "animation",
1749                                                             ICO_HS_ANIMATION_FADE);
1750     moveZoneAnimation.time = config->ConfigGetInteger("switchzone",
1751                                                       "animatime", 400);
1752     // debug log
1753     ICO_DBG("moveZoneName=%s animation=%s time=%d",
1754             moveZoneName, moveZoneAnimation.name, moveZoneAnimation.time);
1755
1756     // AUL Listen Signal set(launch/dead)
1757     initAulListenXSignal();
1758
1759     // application history class init. before call launchApps
1760     InitializeAppHistory();
1761
1762     /* application history launch */
1763     t_launcApps_data* x = new t_launcApps_data;
1764     CicoHSCmdOpts* cmdOpts = CicoHSCmdOpts::getInstance();
1765     x->filePath  = cmdOpts->getHistoryFilePath();
1766     x->filePathD = cmdOpts->getDefaultHistoryFilePath();
1767     x->hs        = this;
1768     ecore_timer_add(0.01, launchApps, x);
1769
1770     /* Create BackGround window */
1771     CreateBackWindow();
1772
1773     /* Create SwipeInput window */
1774     CicoHSSwipeTouch::Initialize(hs_instance->ctl_bar_window, hs_instance->m_appHis,
1775                                  full_width, full_height);
1776     CreateSwipeInputWindow();
1777
1778     /* Create ControlBar window */
1779     CreateControlBarWindow();
1780
1781     /* Create Menu window       */
1782     CreateMenuWindow();
1783
1784     /*Show Home Screen*/
1785     ShowHomeScreenLayer();
1786
1787     ICO_TRA("CicoHomeScreen::StartHomeScreen Leave");
1788     return 0;
1789 }
1790
1791 /*--------------------------------------------------------------------------*/
1792 /**
1793  * @brief   CicoHomeScreen::GetMode
1794  *          Get status
1795  *
1796  * @param[in]   mode status
1797  * @return      none
1798  */
1799 /*--------------------------------------------------------------------------*/
1800 int
1801 CicoHomeScreen::GetMode(void)
1802 {
1803     return mode;
1804 }
1805
1806 /*--------------------------------------------------------------------------*/
1807 /**
1808  * @brief   CicoHomeScreen::SetMode
1809  *          Set status
1810  *
1811  * @param[in]   mode status
1812  * @return      none
1813  */
1814 /*--------------------------------------------------------------------------*/
1815 void
1816 CicoHomeScreen::SetMode(int mode)
1817 {
1818     this->mode = mode;
1819 }
1820
1821 /*--------------------------------------------------------------------------*/
1822 /**
1823  * @brief   CicoHomeScreen::ChangeMode
1824  *          Change status
1825  *
1826  * @param[in]   none
1827  * @return      none
1828  */
1829 /*--------------------------------------------------------------------------*/
1830 void
1831 CicoHomeScreen::ChangeMode(int pattern)
1832 {
1833     int idx;
1834
1835     if (hs_instance->menu_window == NULL)   {
1836         return;
1837     }
1838
1839     if (hs_instance->GetMode() == ICO_HS_MODE_MENU) {
1840         ico_syc_animation_t animation;
1841         ICO_DBG("CicoHomeScreen::ChangeMode: MENU->APP");
1842         if (pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE)  {
1843             animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1844         }
1845         else    {
1846             animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_FADE;
1847         }
1848         animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1849         hs_instance->menu_window->Hide(&animation);
1850         for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++)    {
1851             hs_instance->swipe_input_windows[idx]->Show();
1852         }
1853         hs_instance->SetMode(ICO_HS_MODE_APPLICATION);
1854         CicoHSAppInfo *appinfo = hs_instance->GetActiveAppInfo();
1855         if (NULL != appinfo) {
1856             ico_syc_change_active(appinfo->GetAppId(), appinfo->GetLastSurface());
1857         }
1858     }
1859     else if (hs_instance->GetMode() ==ICO_HS_MODE_APPLICATION)  {
1860         ico_syc_animation_t animation;
1861         ICO_DBG("CicoHomeScreen::ChangeMode: APP->MENU");
1862         if (pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE)  {
1863             animation.name = (char*)ICO_HS_MENU_SHOW_ANIMATION_SLIDE;
1864         }
1865         else    {
1866             animation.name = (char*)ICO_HS_MENU_SHOW_ANIMATION_FADE;
1867         }
1868         animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1869         hs_instance->menu_window->Show(&animation);
1870         for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++)    {
1871             hs_instance->swipe_input_windows[idx]->Hide();
1872         }
1873         hs_instance->SetMode(ICO_HS_MODE_MENU);
1874     }
1875 }
1876
1877 /*--------------------------------------------------------------------------*/
1878 /**
1879  * @brief   CicoHomeScreen::ExecuteApp
1880  *          execute application
1881  *
1882  * @param[in]   appid
1883  * @return      none
1884  */
1885 /*--------------------------------------------------------------------------*/
1886 void
1887 CicoHomeScreen::ExecuteApp(const char*appid)
1888 {
1889     hs_instance->ExecuteApp_i(appid);
1890 }
1891
1892 /*--------------------------------------------------------------------------*/
1893 /**
1894  * @brief   CicoHomeScreen::TerminateApp
1895  *          teminate application
1896  *
1897  * @param[in]   appid
1898  * @return      none
1899  */
1900 /*--------------------------------------------------------------------------*/
1901 void
1902 CicoHomeScreen::TerminateApp(const char*appid)
1903 {
1904     hs_instance->TerminateApp_i(appid);
1905 }
1906
1907 /*--------------------------------------------------------------------------*/
1908 /**
1909  * @brief   CicoHomeScreen::setActiveApp
1910  *          active(touch operate app) notice
1911  *
1912  * @param[in]   appid
1913  * @return      none
1914  */
1915 /*--------------------------------------------------------------------------*/
1916 void
1917 CicoHomeScreen::setActiveApp(const char* appid)
1918 {
1919     if ((NULL == appid) || (0 == appid) || (0 == strlen(appid))) {
1920         return;
1921     }
1922     if (NULL != m_appHis) {
1923         m_appHis->activeApp(appid);
1924     }
1925 }
1926
1927 /*--------------------------------------------------------------------------*/
1928 /**
1929  * @brief   CicoHomeScreen::SetNightMode
1930  *          set night mode theme
1931  *
1932  * @param[in]   data    user data
1933  */
1934 /*--------------------------------------------------------------------------*/
1935 void
1936 CicoHomeScreen::SetNightMode(void* data)
1937 {
1938     ICO_TRA("CicoHomeScreen::SetNightMode Enter");
1939    // night mode action
1940     hs_instance->ctl_bar_window->SetNightMode();
1941     hs_instance->menu_window->SetNightMode();
1942     ICO_TRA("CicoHomeScreen::SetNightMode Leave");
1943 }
1944
1945 /*--------------------------------------------------------------------------*/
1946 /**
1947  * @brief   CicoHomeScreen::SetRegulation
1948  *          regulation action and set regualtion theme
1949  *
1950  * @param[in]   data    user data
1951  */
1952 /*--------------------------------------------------------------------------*/
1953 void
1954 CicoHomeScreen::SetRegulation(void* data)
1955 {
1956     ICO_TRA("CicoHomeScreen::SetRegulation Enter");
1957     // window control
1958     hs_instance->controlRegulation();
1959     // regulation action
1960     hs_instance->ctl_bar_window->SetRegulation();
1961     ico_syc_animation_t animation;
1962     animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1963     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1964     hs_instance->menu_window->Hide(&animation);
1965
1966     // force focus change
1967     if (false == CicoHSSystemState::getInstance()->getRegulation()) {
1968         CicoHSAppInfo *active_appinfo = hs_instance->GetActiveAppInfo();
1969         if (NULL != active_appinfo) {
1970             ico_syc_change_active(active_appinfo->GetAppId(),
1971                                   active_appinfo->GetLastSurface());
1972             ico_syc_change_active(active_appinfo->GetAppId(), 0);
1973         }
1974     }
1975     else {
1976         if (NULL != hs_instance->ctl_bar_window) {
1977             const char *ctl_bar_appid = hs_instance->ctl_bar_window->GetAppId();
1978             int ctl_bar_surface = hs_instance->ctl_bar_window->GetSurfaceId();
1979             ico_syc_change_active(ctl_bar_appid, ctl_bar_surface);
1980             ico_syc_change_active(ctl_bar_appid, 0);
1981         }
1982     }
1983
1984     ICO_TRA("CicoHomeScreen::SetRegulation Leave");
1985 }
1986
1987 /*--------------------------------------------------------------------------*/
1988 /**
1989  * @brief   CicoHomeScreen::RenewAppInfoList_i
1990  *          renewal application info list
1991  *
1992  * @param[in]   none
1993  * @return      none
1994  */
1995 /*--------------------------------------------------------------------------*/
1996 void
1997 CicoHomeScreen::RenewAppInfoList_i(void)
1998 {
1999     int ii = 0;
2000     int kk = 0;
2001     CicoHSAppInfo *tmp_apps_info[ICO_HS_MAX_APP_NUM];
2002     int tmp_application_num = 0;
2003     const char *appid_p = 0;
2004
2005     for(ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++){
2006         tmp_apps_info[ii] = NULL;
2007     }
2008
2009     /* get APP information*/
2010     std::vector<CicoAilItems> aillist = life_cycle_controller->getAilList();
2011
2012     /*create instance*/
2013     for ( ii = 0;
2014          (ii < (int)aillist.size()) && (ii < ICO_HS_MAX_APP_NUM);
2015          ii++)  {
2016         ICO_DBG("aillist[%d].m_appid.c_str() = %s",
2017                  ii, aillist[ii].m_appid.c_str());
2018
2019         for (kk = 0; kk < ICO_HS_MAX_APP_NUM; kk++) {
2020             if (apps_info[kk] == NULL) {
2021                 continue;
2022             }
2023
2024             if (strcmp(aillist[ii].m_appid.c_str(),
2025                 apps_info[kk]->GetAppId()) == 0) {
2026
2027                 tmp_apps_info[ii] = apps_info[kk];
2028                 ICO_DBG("shift aillist[%d].m_appid.c_str() = %s",
2029                          ii, aillist[ii].m_appid.c_str());
2030                 break;
2031             }
2032         }
2033         if (kk == ICO_HS_MAX_APP_NUM) {
2034             tmp_apps_info[ii] = new CicoHSAppInfo(aillist[ii].m_appid.c_str());
2035             ICO_DBG("create aillist[%d].m_appid.c_str() = %s",
2036                      ii, aillist[ii].m_appid.c_str());
2037         }
2038         tmp_application_num++;
2039     }
2040
2041     /* delete instance */
2042     for (ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
2043         if (apps_info[ii] == NULL) {
2044             continue;
2045         }
2046         appid_p = apps_info[ii]->GetAppId();
2047         for ( kk = 0; kk < tmp_application_num; kk++) {
2048             if (strcmp(appid_p, tmp_apps_info[kk]->GetAppId()) == 0) {
2049                 break;
2050             }
2051         }
2052         if (kk == tmp_application_num) {
2053             delete apps_info[ii];
2054             ICO_DBG("delete apps_info[%d]->GetAppId() = %s",
2055                     ii, appid_p);
2056         }
2057     }
2058
2059     /* set apps info */
2060     for ( ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
2061         apps_info[ii] = tmp_apps_info[ii];
2062     }
2063
2064     application_num = tmp_application_num;
2065 }
2066
2067 /*--------------------------------------------------------------------------*/
2068 /**
2069  * @brief   CicoHomeScreen::RenewAppInfoList
2070  *          renewal appinfolist
2071  *
2072  * @param[in]   none
2073  * @return      none
2074  */
2075 /*--------------------------------------------------------------------------*/
2076 void
2077 CicoHomeScreen::RenewAppInfoList(void)
2078 {
2079     ICO_TRA("CicoHomeScreen::RenewAppInfoList Enter");
2080     hs_instance->RenewAppInfoList_i();
2081     ICO_TRA("CicoHomeScreen::RenewAppInfoList Leave");
2082 }
2083
2084 /*--------------------------------------------------------------------------*/
2085 /**
2086  * @brief   CicoHomeScreen::startupCheckAdd
2087  *          start-up application infomation add
2088  *
2089  * @param[in]  pid
2090  * @param[in]  appid
2091  * @return     none
2092  */
2093 /*--------------------------------------------------------------------------*/
2094 void CicoHomeScreen::startupCheckAdd(int pid, const std::string& appid,
2095                                      bool bSubDisp)
2096 {
2097     if (NULL != m_appHis) {
2098         m_appHis->startupCheckAdd(pid, appid, bSubDisp);
2099     }
2100 }
2101
2102 /*--------------------------------------------------------------------------*/
2103 /**
2104  * @brief   CicoHomeScreen::startupCheck
2105  *          start-up application check
2106  *
2107  * @param[in]  appid check target
2108  */
2109 /*--------------------------------------------------------------------------*/
2110 void CicoHomeScreen::startupCheck(const char* appid)
2111 {
2112     ICO_TRA("CicoHomeScreen::startupCheck Enter");
2113     if (NULL == life_cycle_controller) {
2114         ICO_ERR("life_cycle_controller is null");
2115         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2116         return;
2117     }
2118     if (NULL == m_appHis) {
2119         ICO_ERR("m_appHis is null");
2120         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2121         return;
2122     }
2123     if (false == m_appHis->isStartupChecking()) {
2124         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2125         return;
2126     }
2127     m_appHis->update_appid();
2128     m_appHis->startupEntryFinish(appid);
2129     if (false == m_appHis->isFinish()) {
2130         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2131         return;
2132     }
2133     finishStartup();
2134     ICO_TRA("CicoHomeScreen::startupCheck Leave");
2135 }
2136
2137 /*--------------------------------------------------------------------------*/
2138 /**
2139  * @brief   CicoHomeScreen::finishStartup
2140  *          start-up application check
2141  *
2142  * @param[in]  appid check target
2143  */
2144 /*--------------------------------------------------------------------------*/
2145
2146 void CicoHomeScreen::finishStartup(void)
2147 {
2148     ICO_TRA("CicoHomeScreen::finishStartup Enter");
2149
2150     string last = m_appHis->getLastStartupAppid();
2151     const string& subDisp = m_appHis->getSubDispAppid();
2152
2153     list<string> h = m_appHis->getAppHistory();
2154     // last appid is empty then get new last appid
2155     if (true == last.empty()) {
2156         list<string>::iterator it_h = h.begin();
2157         while (it_h != h.end()) {
2158             if (0 != subDisp.compare(*it_h)) {
2159                 last = *it_h;
2160             }
2161             ++it_h;
2162         }
2163     }
2164
2165     list<string>::reverse_iterator rit_h = h.rbegin();
2166     while(rit_h != h.rend()) {
2167         CicoHSAppInfo *ai = GetAppInfo((*rit_h).c_str());
2168         if (ai == NULL) {
2169             ++rit_h;
2170             continue;
2171         }
2172         ICO_DBG("Raise %s", (*rit_h).c_str());
2173         {
2174             const char* appid = ai->GetAppId();
2175             int surface = ai->GetLastSurface();
2176             if ((0 != last.compare(appid)) && (0 != subDisp.compare(appid))) {
2177                 ico_syc_show(appid, surface, NULL);
2178                 ico_syc_hide(appid, surface, NULL);
2179             }
2180         }
2181         ++rit_h;
2182     }
2183
2184     CicoHSAppInfo *ai = GetAppInfo(subDisp.c_str());
2185     if (ai != NULL) {
2186         requestChangeZone(ai);
2187     }
2188
2189     ai = GetAppInfo(last.c_str());
2190     if (ai != NULL) {
2191         const char* appid = ai->GetAppId();
2192         int surface = ai->GetLastSurface();
2193         ico_syc_show(appid, surface, NULL);
2194         ico_syc_change_active(appid, surface);
2195         hs_instance->SetActiveAppInfo(appid);
2196     }
2197
2198     m_appHis->stopStartupCheck();
2199     ICO_TRA("CicoHomeScreen::finishStartup Leave");
2200 }
2201
2202 /*--------------------------------------------------------------------------*/
2203 /**
2204  * @brief   CicoHomeScreen::readStartupApp
2205  *          read start-up application data
2206  *
2207  * @param[in]  appid check target
2208  */
2209 /*--------------------------------------------------------------------------*/
2210 void CicoHomeScreen::readStartupApp(std::vector<pairAppidSubd>& apps)
2211 {
2212     ICO_TRA("CicoHomeScreen::readStartupApp Enter");
2213     if (NULL == m_appHis) {
2214         apps.clear();
2215     }
2216     else {
2217         m_appHis->readAppHistory(apps);
2218     }
2219     ICO_TRA("CicoHomeScreen::readStartupApp Leave(%d)", (int)apps.size());
2220     return;
2221 }
2222
2223 /*--------------------------------------------------------------------------*/
2224 /**
2225  * @brief   CicoHomeScreen::requestHideAppid
2226  *          request Hide appid
2227  *
2228  * @param  app appid
2229  */
2230 /*--------------------------------------------------------------------------*/
2231 void CicoHomeScreen::requestHideAppid(const std::string& app)
2232 {
2233     const char* appid = app.c_str();
2234     ICO_TRA("start %s", appid);
2235     CicoHSAppInfo *ai = GetAppInfo(appid);
2236     if (NULL == ai) {
2237         ICO_DBG("end %d", appid);
2238         return;
2239     }
2240     int surface = ai->GetLastSurface();
2241     ico_syc_hide(appid, surface, NULL);
2242     ICO_TRA("end");
2243 }
2244
2245 /*--------------------------------------------------------------------------*/
2246 /**
2247  * @brief   CicoHomeScreen::requestShowAppid
2248  *          request Show appid
2249  *
2250  * @param  app appid
2251  */
2252 /*--------------------------------------------------------------------------*/
2253 void CicoHomeScreen::requestShowAppid(const std::string& app)
2254 {
2255     const char* appid = app.c_str();
2256     ICO_TRA("start %s", appid);
2257     CicoHSAppInfo *ai = GetAppInfo(appid);
2258     if (NULL == ai) {
2259         ICO_DBG("end %d", appid);
2260         return;
2261     }
2262     int surface = ai->GetLastSurface();
2263     ico_syc_show(appid, surface, NULL);
2264     ICO_TRA("end");
2265 }
2266
2267 /*--------------------------------------------------------------------------*/
2268 /**
2269  * @brief   CicoHomeScreen::requestActivationAppid
2270  *          request Activation
2271  *
2272  * @param  app appid
2273  */
2274 /*--------------------------------------------------------------------------*/
2275 void CicoHomeScreen::requestActivationAppid(const std::string& app)
2276 {
2277     const char* appid = app.c_str();
2278     ICO_TRA("CicoHomeScreen::requestActivationAppid Enter(%s)", appid);
2279     CicoHSAppInfo *ai = GetAppInfo(appid);
2280     if (NULL == ai) {
2281         ICO_DBG("end %d", appid);
2282         return;
2283     }
2284     int surface = ai->GetLastSurface();
2285     hs_instance->SetActiveAppInfo(app.c_str());
2286     ico_syc_show(appid, surface, NULL);
2287     ico_syc_change_active(appid, surface);
2288     ICO_TRA("CicoHomeScreen::requestActivationAppid Leave");
2289 }
2290
2291 /*--------------------------------------------------------------------------*/
2292 /**
2293  * @brief   CicoHomeScreen::controlRegulation
2294  *          controlRegulation
2295  *
2296  * @param  reqStt true / false
2297  */
2298 /*--------------------------------------------------------------------------*/
2299 void CicoHomeScreen::controlRegulation(bool regStt)
2300 {
2301     ICO_TRA("CicoHomeScreen::controlRegulation Enter(%s)",
2302             regStt? "true": "false");
2303     if (NULL == m_appHis) {
2304         ICO_ERR("m_appHis is null");
2305         ICO_TRA("CicoHomeScreen::controlRegulation Leave");
2306         return;
2307     }
2308     const string& wapp = m_appHis->getSelectApp(); // select appid get
2309     if (false == wapp.empty()) { // select appid nothing
2310         const string& napp = m_appHis->getNearHistory(); // history top appid get
2311         if (0 != wapp.compare(napp)) { // history top, wait app is Eqale
2312             requestHideAppid(napp);
2313             requestActivationAppid(wapp);
2314             m_appHis->moveHistoryHead(wapp);
2315         }
2316         m_appHis->clearSelectApp(); // select appid clear
2317         m_appHis->homeSwipe();
2318     }
2319     ICO_TRA("CicoHomeScreen::controlRegulation Leave");
2320 }
2321
2322 /*--------------------------------------------------------------------------*/
2323 /**
2324  * @brief   CicoHomeScreen::ActivationUpdate
2325  *          history update by swipe app
2326  *
2327  * @return bool
2328  * @retval true history update
2329  * @retval false no history updath
2330  */
2331 /*--------------------------------------------------------------------------*/
2332 bool
2333 CicoHomeScreen::ActivationUpdate(void)
2334 {
2335     return hs_instance->ActivationUpdate_i();
2336 }
2337
2338 /*--------------------------------------------------------------------------*/
2339 /**
2340  * @brief   CicoHomeScreen::ActivationUpdate_i
2341  *          history update by swipe app
2342  *
2343  * @return bool
2344  * @retval true history update
2345  * @retval false no history updath
2346  */
2347 /*--------------------------------------------------------------------------*/
2348 bool
2349 CicoHomeScreen::ActivationUpdate_i(void)
2350 {
2351     ICO_TRA("CicoHomeScreen::ActivationUpdate_i Enter");
2352     if (NULL == m_appHis) {
2353         ICO_ERR("m_appHis is null");
2354         ICO_TRA("CicoHomeScreen::ActivationUpdate_i Leave(false)");
2355         return false;
2356     }
2357     bool bR = false;
2358     const string& wapp = m_appHis->getSelectApp(); // select appid get
2359     if (false == wapp.empty()) { // select appid nothing
2360         const string& napp = m_appHis->getNearHistory(); // history top appid get
2361         if (0 != wapp.compare(napp)) { // history top, wait app is Eqale
2362             requestActivationAppid(wapp);
2363             m_appHis->moveHistoryHead(wapp);
2364             bR = true;
2365         }
2366         m_appHis->clearSelectApp(); // select appid clear
2367         m_appHis->homeSwipe();
2368     }
2369     ICO_TRA("CicoHomeScreen::ActivationUpdate_i Leave(%s)",
2370             bR? "true": "false");
2371     return bR;
2372 }
2373
2374 /*--------------------------------------------------------------------------*/
2375 /**
2376  * @brief   CicoHomeScreen::ShowApp_i
2377  *          show app
2378  *
2379  * @param  app appid
2380  */
2381 /*--------------------------------------------------------------------------*/
2382 void
2383 CicoHomeScreen::ShowApp_i(const std::string& app)
2384 {
2385     CicoHSAppInfo *appinfo = GetAppInfo(app.c_str());
2386     if (appinfo == NULL)    {
2387         ICO_TRA("end get appinfo is NULL");
2388         return;
2389     }
2390
2391     ico_syc_animation_t animation;
2392     animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_FADE;
2393     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
2394
2395     ico_syc_show(appinfo->GetAppId(), appinfo->GetLastSurface(), &animation);
2396     ico_syc_change_active(appinfo->GetAppId(), appinfo->GetLastSurface());
2397     hs_instance->SetActiveAppInfo(appinfo->GetAppId());
2398     //raise
2399 //    RaiseApplicationWindow(appinfo->GetAppId(),
2400 //                           appinfo->GetLastSurface());
2401     ICO_DBG("raise app %s", app.c_str());
2402     m_appHis->moveHistoryHead(app);
2403 }
2404
2405 /*--------------------------------------------------------------------------*/
2406 /**
2407  * @brief   CicoHomeScreen::ShowApp
2408  *          show app
2409  *
2410  * @param  app appid
2411  */
2412 /*--------------------------------------------------------------------------*/
2413 void
2414 CicoHomeScreen::ShowApp(const std::string& app)
2415 {
2416     hs_instance->ShowApp_i(app);
2417 }
2418
2419 /*--------------------------------------------------------------------------*/
2420 /**
2421  * @brief   CicoHomeScreen::HideAppid
2422  *          hide app
2423  *
2424  * @param  app appid
2425  */
2426 /*--------------------------------------------------------------------------*/
2427 void
2428 CicoHomeScreen::HideApp(const std::string& app)
2429 {
2430     const char* appid = app.c_str();
2431     ICO_TRA("start %s", appid);
2432     CicoHSAppInfo *ai = GetAppInfo(appid);
2433     if (NULL == ai) {
2434         ICO_DBG("end %d", appid);
2435         return;
2436     }
2437
2438     ico_syc_animation_t animation;
2439     animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_FADE;
2440     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
2441
2442     int surface = ai->GetLastSurface();
2443     ico_syc_hide(appid, surface, &animation);
2444     ICO_TRA("end");
2445 }
2446
2447 /*--------------------------------------------------------------------------*/
2448 /**
2449  * @brief   CicoHomeScreen::MoveApp
2450  *          move app
2451  *
2452  * @param  app appid
2453  * @param  zone zone
2454  */
2455 /*--------------------------------------------------------------------------*/
2456 void
2457 CicoHomeScreen::MoveApp(const std::string& app, const std::string& zone)
2458 {
2459     CicoHSAppInfo *appinfo = GetAppInfo((const char*)app.c_str());
2460     if ((CicoHSAppInfo*)0 == appinfo) {
2461         ICO_DBG("GetAppInfo(%s) is NULL" , app.c_str());
2462         return;
2463     }
2464
2465     int surface = appinfo->GetLastSurface();
2466     ico_hs_window_info* wininfo = appinfo->GetWindowInfobySurface(surface);
2467     int layer = HS_LAYER_APPLICATION;
2468     const char *dispzone = (const char*)zone.c_str();
2469     ico_syc_win_move_t move = {
2470         .zone   = (char*)dispzone,
2471         .layer  = layer,
2472         .pos_x  = 0,
2473         .pos_y  = 0,
2474         .width  = 0,
2475         .height = 0
2476     };
2477
2478     ico_syc_move(wininfo->appid, wininfo->surface, &move,
2479                  &hs_instance->moveZoneAnimation);
2480 }
2481 // vim: set expandtab ts=4 sw=4: