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