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(%08x) "
 659             "pos(%d,%d) size(%d,%d)", win_info->appid, win_info->name, win_info->surface,
 660             move. pos_x, move.pos_y, move.width, move.height);
 661     ico_syc_move(win_info->appid, win_info->surface, &move, NULL);
 662
 663     /*first time menu is unvisible*/
 664     if ((strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
 665                  ICO_MAX_TITLE_NAME_LEN) == 0) &&
 666         (GetMode() == ICO_HS_MODE_APPLICATION)) {
 667         ico_syc_hide(win_info->appid, win_info->surface, NULL);
 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
1187     strncpy(sb_package_name,
1188             config->ConfigGetString(ICO_HS_CONFIG_HOMESCREEN,
1189                                     ICO_HS_CONFIG_SB,
1190                                     ICO_HS_APPID_DEFAULT_SB),
1191             ICO_HS_MAX_PROCESS_NAME);
1192     strncpy(os_package_name,
1193             config->ConfigGetString(ICO_HS_CONFIG_HOMESCREEN,
1194                                     ICO_HS_CONFIG_ONS,
1195                                     ICO_HS_APPID_DEFAULT_ONS),
1196             ICO_HS_MAX_PROCESS_NAME);
1197
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
1205     sb_app_info = GetAppInfo(sb_package_name);
1206     ret = sb_app_info->Execute();
1207     if (ret < 0) {
1208         ICO_WRN("execute failed(%s) err=%d", sb_package_name, ret);
1209     }
1210     return ICO_OK;
1211 }
1212
1213 /*--------------------------------------------------------------------------*/
1214 /**
1215  * @brief   CicoHomeScreen::Initialize
1216  *          Initialize
1217  *
1218  * @param[in]   orientation    vertical or horizontal
1219  * @param[in]   config         config
1220  * @return      OK or ERROR
1221  */
1222 /*--------------------------------------------------------------------------*/
1223 int
1224 CicoHomeScreen::Initialize(int orientation, CicoGKeyFileConfig *config)
1225 {
1226
1227     ICO_DBG("CicoHomeScreen::Initialize: start");
1228     /*save instance pointer */
1229     hs_instance = this;
1230
1231     /*config copy*/
1232     this->config = new CicoGKeyFileConfig();
1233     this->config->Initialize(ICO_HOMESCREEN_CONFIG_FILE, ICO_SYC_PACKAGE_HOMESCREEN);
1234
1235     /*Get application info*/
1236     CreateAppInfoList();
1237
1238     /* get pkg name (home screen,status bar,on screen)*/
1239     char *pkg;
1240     ICO_DBG("CicoHomeSceen::Initialize: %s: %s",
1241             getenv("HOME"), getenv("PKG_NAME"));
1242     pkg = getenv("PKG_NAME");
1243     memset(hs_package_name, 0, ICO_HS_MAX_PROCESS_NAME);
1244     if (pkg)    {
1245         strncpy(hs_package_name, pkg, ICO_HS_MAX_PROCESS_NAME);
1246     }
1247     else    {
1248         strncpy(hs_package_name, ICO_HS_PROC_DEFAULT_HOMESCREEN,
1249                 ICO_HS_MAX_PROCESS_NAME);
1250     }
1251
1252     /* Initialize WindowController */
1253     CicoHSWindowController::Initialize();
1254     ICO_DBG("CicoHomeScreen::Initialize: window controller initialized");
1255
1256     ICO_DBG("CicoHomeScreen::Initialize: start connect to systemcontroller");
1257     ico_syc_connect(EventCallBack,NULL);
1258     ICO_DBG("CicoHomeScreen::Initialize: end connect to systemcontroller");
1259
1260     /*initialize system controller*/
1261     /*my info*/
1262     ICO_DBG("CicoHomeScreen::Initialize: get package name %s",hs_package_name);
1263     hs_app_info = GetAppInfo(hs_package_name);
1264
1265     /*start home statusbar and onscreen*/
1266     StartRelations();
1267     ICO_DBG("CicoHomeScreen::Initialize: start relation apps");
1268
1269     /* Get screen size */
1270     CicoHSWindowController::GetFullScreenSize(orientation,
1271                                               &full_width,&full_height);
1272
1273     ICO_DBG("full screen size x=%d y=%d",full_width,full_height);
1274
1275     /* MenuScreen Window Size */
1276     menu_width = full_width;
1277     menu_height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
1278                   ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1279
1280     /* BackGround Window Size */
1281     bg_width = full_width;
1282     bg_height = full_height;
1283
1284     /* Control Bar Window Size */
1285     ctl_bar_width = full_width;
1286     ctl_bar_height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1287
1288     // load switch display zone config
1289     moveZoneName = config->ConfigGetString("switchzone", "movezone", NULL);
1290
1291     moveZoneAnimation.name = config->ConfigGetString("switchzone",
1292                                                      "animation",
1293                                                      ICO_HS_ANIMATION_FADE);
1294
1295     moveZoneAnimation.time = config->ConfigGetInteger("switchzone",
1296                                                       "animatime", 400);
1297
1298     // debug log
1299     ICO_DBG("moveZoneName=%s animation=%s time=%d",
1300             moveZoneName, moveZoneAnimation.name, moveZoneAnimation.time);
1301
1302     ICO_DBG("CicoHomeScreen::Initialize: end");
1303
1304     return ICO_OK;
1305 }
1306
1307 /*--------------------------------------------------------------------------*/
1308 /**
1309  * @brief   CicoHomeScreen::InitializeAppHistory
1310  *          Initialize application History Manager
1311  */
1312 /*--------------------------------------------------------------------------*/
1313 void
1314 CicoHomeScreen::InitializeAppHistory(void)
1315 {
1316     ICO_DBG("start");
1317     if (NULL != m_appHis) {
1318         ICO_DBG("end");
1319         return;
1320     }
1321     CicoHSCmdOpts* cmdOpts = CicoHSCmdOpts::getInstance();
1322     m_appHis = new CicoHSAppHistoryExt(cmdOpts->getLoginUser(),
1323                                        cmdOpts->getHistoryFilePath(),
1324                                        cmdOpts->getDefaultHistoryFilePath(),
1325                                        cmdOpts->getFlagPath());
1326     m_appHis->force_flagoff();
1327     m_appHis->setHomeScreen(this);
1328
1329     const char* val;
1330     val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1331                                   ICO_HS_CONFIG_HSTRY_KEY1,
1332                                   ICO_HS_CONFIG_HSTRY_DEF1);
1333     ICO_DBG("timer = %s", val);
1334     double dV = atof(val);
1335     m_appHis->setWaitTime(dV);
1336
1337     val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1338                                   ICO_HS_CONFIG_HSTRY_KEY2,
1339                                   ICO_HS_CONFIG_HSTRY_DEF2);
1340     vector<string> vvM;
1341     if ((NULL != val) && (0 != val) && (0 != strlen(val))) {
1342         string tmpM(val);
1343         split(tmpM, ICO_HS_CONFIG_HSTRY_SPL, vvM);
1344     }
1345     if (0 != vvM.size()) {
1346         ICO_DBG("manage off = %s split=%d", val, (int)vvM.size());
1347         m_appHis->setFilterManage(vvM);
1348     }
1349     val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1350                                   ICO_HS_CONFIG_HSTRY_KEY3,
1351                                   ICO_HS_CONFIG_HSTRY_DEF3);
1352     vector<string> vvW;
1353     if ((NULL != val) && (0 != val) && (0 != strlen(val))) {
1354         string tmpW(val);
1355         split(tmpW, ICO_HS_CONFIG_HSTRY_SPL, vvW);
1356     }
1357     if (0 != vvW.size()) {
1358         ICO_DBG("write off = %s, split=%d", val, (int)vvW.size());
1359         m_appHis->setFilterWrite(vvW);
1360     }
1361     ICO_DBG("end");
1362 }
1363
1364 /*--------------------------------------------------------------------------*/
1365 /**
1366  * @brief   CicoHomeScreen::Finalize
1367  *          Finalize
1368  *
1369  * @param[in]   none
1370  * @return      none
1371  */
1372 /*--------------------------------------------------------------------------*/
1373 void
1374 CicoHomeScreen::Finalize(void)
1375 {
1376     /* Finalize WindowController */
1377     CicoHSWindowController::Finalize();
1378
1379     ico_syc_disconnect();
1380
1381     delete hs_app_info;
1382 }
1383
1384 /*--------------------------------------------------------------------------*/
1385 /**
1386  * @brief   CicoHomeScreen::CreateMenuWindow
1387  *          create menu window
1388  *
1389  * @param[in]   none
1390  * @return      none
1391  */
1392 /*--------------------------------------------------------------------------*/
1393 void
1394 CicoHomeScreen::CreateMenuWindow(void)
1395 {
1396     /*create window*/
1397     ICO_DBG("CicoHomeScreen::CreateMenuWindow: start");
1398     menu_window = new CicoHSMenuWindow();
1399     menu_window->CreateMenuWindow(ICO_HS_WINDOW_POS_X,ICO_HS_WINDOW_POS_Y,
1400                                   menu_width,menu_height);
1401     menu_window->ShowWindow();
1402     ICO_DBG("CicoHomeScreen::CreateMenuWindow: end");
1403 }
1404
1405 /*--------------------------------------------------------------------------*/
1406 /**
1407  * @brief   CicoHomeScreen::DeleteMenuWindow
1408  *          delete menu window
1409  *
1410  * @param[in]   none
1411  * @return      none
1412  */
1413 /*--------------------------------------------------------------------------*/
1414 void
1415 CicoHomeScreen::DeleteMenuWindow(void)
1416 {
1417     if (menu_window == NULL)    {
1418         return;
1419     }
1420     menu_window->FreeMenuWindow();
1421     delete menu_window;
1422
1423 }
1424
1425 /*--------------------------------------------------------------------------*/
1426 /**
1427  * @brief   CicoHomeScreen::UpdateMenuWindow
1428  *          update menu window
1429  *
1430  * @param[in]   none
1431  * @return      none
1432  */
1433 /*--------------------------------------------------------------------------*/
1434 void
1435 CicoHomeScreen::UpDateMenuWindow(void)
1436 {
1437     DeleteMenuWindow();
1438     CreateMenuWindow();
1439 }
1440
1441 /*--------------------------------------------------------------------------*/
1442 /**
1443  * @brief   CicoHomeScreen::CreateBackWindow
1444  *          create back window
1445  *
1446  * @param[in]   none
1447  * @return      none
1448  */
1449 /*--------------------------------------------------------------------------*/
1450 void
1451 CicoHomeScreen::CreateBackWindow(void)
1452 {
1453     /*create window*/
1454     ICO_DBG("CicoHomeScreen::CreateBackWindow");
1455     back_window = new CicoHSBackWindow();
1456     back_window->CreateBackWindow(ICO_HS_WINDOW_POS_X,ICO_HS_WINDOW_POS_Y,
1457                                   bg_width,bg_height);
1458     back_window->ShowWindow();
1459 }
1460
1461 /*--------------------------------------------------------------------------*/
1462 /**
1463  * @brief   CicoHomeScreen::CreateBackWindow
1464  *          create back window
1465  *
1466  * @param[in]   none
1467  * @return      none
1468  */
1469 /*--------------------------------------------------------------------------*/
1470 void
1471 CicoHomeScreen::DeleteBackWindow(void)
1472 {
1473     if (back_window == NULL)    {
1474         return;
1475     }
1476     back_window->FreeBackWindow();
1477     delete back_window;
1478 }
1479
1480 /*--------------------------------------------------------------------------*/
1481 /**
1482  * @brief   CicoHomeScreen::UpDateBackWindow
1483  *          update back window
1484  *
1485  * @param[in]   none
1486  * @return      none
1487  */
1488 /*--------------------------------------------------------------------------*/
1489 void
1490 CicoHomeScreen::UpDateBackWindow(void)
1491 {
1492     DeleteBackWindow();
1493     CreateBackWindow();
1494 }
1495
1496 /*--------------------------------------------------------------------------*/
1497 /**
1498  * @brief   CicoHomeScreen::CreateControlBarWindow
1499  *          create control bar window
1500  *
1501  * @param[in]   none
1502  * @return      none
1503  */
1504 /*--------------------------------------------------------------------------*/
1505 void
1506 CicoHomeScreen::CreateControlBarWindow(void)
1507 {
1508     /*create window*/
1509     ICO_DBG("CicoHomeScreen::CreateControlBarWindow");
1510     ctl_bar_window = new CicoHSControlBarWindow();
1511     ctl_bar_window->CreateControlBarWindow(ICO_HS_MENU_WINDOW_POS_X,bg_height -
1512                                            ctl_bar_height,ctl_bar_width,
1513                                            ctl_bar_height);
1514     ctl_bar_window->ShowWindow();
1515 }
1516
1517 /*--------------------------------------------------------------------------*/
1518 /**
1519  * @brief   CicoHomeScreen::DeleteControlBarWindow
1520  *          delete control bar window
1521  *
1522  * @param[in]   none
1523  * @return      none
1524  */
1525 /*--------------------------------------------------------------------------*/
1526 void
1527 CicoHomeScreen::DeleteControlBarWindow(void)
1528 {
1529     if (ctl_bar_window == NULL) {
1530         return;
1531     }
1532     ctl_bar_window->FreeControlBarWindow();
1533     delete ctl_bar_window;
1534 }
1535
1536 /*--------------------------------------------------------------------------*/
1537 /**
1538  * @brief   CicoHomeScreen::CreateSwipeInputWindow
1539  *          create swipe input windows
1540  *
1541  * @param[in]   none
1542  * @return      none
1543  */
1544 /*--------------------------------------------------------------------------*/
1545 void
1546 CicoHomeScreen::CreateSwipeInputWindow(void)
1547 {
1548     int     pos_y, swipe_height;
1549
1550     ICO_DBG("CicoHomeScreen::CreateSwipeInputWindow: start");
1551     /* cullentry SwipeInput windows is fixed size   */
1552     pos_y = ICO_HS_WINDOW_POS_Y + ICO_HS_SWIPE_TOUCH_DISTANCE_TOP;
1553     swipe_height = full_height - pos_y - ICO_HS_SWIPE_TOUCH_DISTANCE_BOTTOM;
1554
1555     /* left side window     */
1556     swipe_input_windows[0] = new CicoHSSwipeInputWindow();
1557     swipe_input_windows[0]->
1558             CreateSwipeInputWindow(ICO_HS_WINDOW_POS_X, pos_y,
1559                                    ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, swipe_height,
1560                                    "left");
1561     swipe_input_windows[0]->ShowWindow();
1562
1563     /* right side window    */
1564     swipe_input_windows[1] = new CicoHSSwipeInputWindow();
1565     swipe_input_windows[1]->
1566             CreateSwipeInputWindow(full_width - ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, pos_y,
1567                                    ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, swipe_height,
1568                                    "right");
1569     swipe_input_windows[1]->ShowWindow();
1570
1571 #if 0       /* currently not support(not fix specification) */
1572     /* buttom side window   */
1573     swipe_input_windows[2] = new CicoHSSwipeInputWindow();
1574     swipe_input_windows[2]->
1575             CreateSwipeInputWindow(ICO_HS_WINDOW_POS_X,
1576                                    full_height - ICO_HS_SWIPE_TOUCH_SWIPE_HEIGHT,
1577                                    full_width, ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, "buttom");
1578
1579     swipe_input_windows[2]->ShowWindow();
1580     num_swipe_input_windows = 3;
1581 #else
1582     num_swipe_input_windows = 2;
1583 #endif
1584     ICO_DBG("CicoHomeScreen::CreateSwipeInputWindow: end");
1585 }
1586
1587 /*--------------------------------------------------------------------------*/
1588 /**
1589  * @brief   CicoHomeScreen::DeleteSwipeInputWindow
1590  *          delete swipe input windows
1591  *
1592  * @param[in]   none
1593  * @return      none
1594  */
1595 /*--------------------------------------------------------------------------*/
1596 void
1597 CicoHomeScreen::DeleteSwipeInputWindow(void)
1598 {
1599     int idx;
1600
1601     for (idx = 0; idx < num_swipe_input_windows; idx++) {
1602         if (swipe_input_windows[idx])   {
1603             swipe_input_windows[idx]->FreeSwipeInputWindow();
1604             delete swipe_input_windows[idx];
1605             swipe_input_windows[idx] = NULL;
1606         }
1607     }
1608     num_swipe_input_windows = 0;
1609 }
1610
1611 /*--------------------------------------------------------------------------*/
1612 /**
1613  * @brief   launch applications
1614  *
1615  * @param   filepath  start applications list file path
1616  * @param   filepathD defalt start applications list file path
1617  * @return  bool
1618  * @retval  true  success
1619  * @retval  false fail
1620  */
1621 /*--------------------------------------------------------------------------*/
1622 static Eina_Bool launchApps(void* data)
1623 {
1624     ICO_DBG("start");
1625     launcApps_data_t* x = (launcApps_data_t*) data;
1626     if ((NULL == x) || (NULL == x->hs)) {
1627         ICO_DBG("end fail");
1628         return ECORE_CALLBACK_CANCEL;
1629     }
1630
1631     vector<pairAppidSubd> apps;
1632     x->hs->readStartupApp(apps);
1633
1634     int sz = apps.size();
1635     for (int i =sz; i > 0; i--) {
1636         string appid = apps[i-1].first;
1637         bool bFLAG = apps[i-1].second;
1638         const char* app = appid.c_str();
1639         ICO_PRF("CHG_APP_STA 1.request app=%s", app);
1640         int pid = aul_launch_app(appid.c_str(), NULL);
1641         ICO_DBG("            1.request [%d]%d:%s:%d", i, pid, app, (int)bFLAG);
1642         if ((0 < pid) && (NULL != x->hs)) {
1643             x->hs->startupCheckAdd(pid, appid, bFLAG);
1644         }
1645     }
1646     ICO_DBG("end success");
1647     return ECORE_CALLBACK_CANCEL;
1648 }
1649
1650 /*--------------------------------------------------------------------------*/
1651 /**
1652  * @brief   CicoHomeScreen::StartHomeScreen
1653  *          start home screen
1654  *
1655  * @param[in]   none
1656  * @return      none
1657  */
1658 /*--------------------------------------------------------------------------*/
1659 int
1660 CicoHomeScreen::StartHomeScreen(int orientation)
1661 {
1662     int     retry;
1663
1664     ICO_TRA("CicoHomeScreen::StartHomeScreen Enter");
1665
1666     /*save instance pointer */
1667     hs_instance = this;
1668
1669     /*config copy*/
1670     this->config = new CicoGKeyFileConfig();
1671     this->config->Initialize(ICO_HOMESCREEN_CONFIG_FILE, ICO_SYC_PACKAGE_HOMESCREEN);
1672
1673     /* init home screen soud */
1674     CicoSound::GetInstance()->Initialize(this->config);
1675
1676     /*Get application info*/
1677     CreateAppInfoList();
1678
1679     /* get pkg name (home screen,status bar,on screen)*/
1680     char *pkg;
1681     ICO_DBG("CicoHomeSceen::StartHomeScreen: %s: %s",
1682             getenv("HOME"), getenv("PKG_NAME"));
1683     pkg = getenv("PKG_NAME");
1684     memset(hs_package_name, 0, ICO_HS_MAX_PROCESS_NAME);
1685     if (pkg)    {
1686         strncpy(hs_package_name, pkg, ICO_HS_MAX_PROCESS_NAME);
1687     }
1688     else    {
1689         strncpy(hs_package_name, ICO_HS_PROC_DEFAULT_HOMESCREEN,
1690                 ICO_HS_MAX_PROCESS_NAME);
1691     }
1692
1693     /* create application control instance */
1694     CicoHSAppControl *m_appctrl = CicoHSAppControl::getInstance();
1695
1696     /* create server instance */
1697     CicoHSServer *server = CicoHSServer::getInstance();
1698     server->setAppCtrl(m_appctrl);
1699     server->startup(10001, "ico_hs_protocol");
1700
1701     /* Initialize WindowController */
1702     CicoHSWindowController::Initialize();
1703     ICO_DBG("CicoHomeScreen::StartHomeScreen: window controller initialized");
1704
1705     ICO_DBG("CicoHomeScreen::StartHomeScreen: start connect to systemcontroller");
1706     ico_syc_connect(EventCallBack,NULL);
1707     for (retry = 0; retry < (2000/10); retry++) {
1708         ico_syc_service();
1709         if (ico_syc_isconnect())    break;
1710         usleep(10*1000);
1711     }
1712     ICO_DBG("CicoHomeScreen::StartHomeScreen: end connect to systemcontroller");
1713
1714     /*initialize system controller*/
1715     /*my info*/
1716     ICO_DBG("CicoHomeScreen::StartHomeScreen: get package name %s",hs_package_name);
1717     hs_app_info = GetAppInfo(hs_package_name);
1718
1719     /*start home statusbar and onscreen*/
1720     StartRelations();
1721     ICO_DBG("CicoHomeScreen::StartHomeScreen: start relation apps");
1722
1723     /* Get screen size */
1724     CicoHSWindowController::GetFullScreenSize(orientation,
1725                                               &full_width,&full_height);
1726
1727     ICO_DBG("full screen size x=%d y=%d",full_width,full_height);
1728
1729     /* MenuScreen Window Size */
1730     menu_width = full_width;
1731     menu_height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
1732                   ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1733
1734     /* BackGround Window Size */
1735     bg_width  = full_width;
1736     bg_height = full_height;
1737
1738     /* Control Bar Window Size */
1739     ctl_bar_width  = full_width;
1740     ctl_bar_height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1741
1742     // load switch display zone config
1743     moveZoneName = config->ConfigGetString("switchzone", "movezone", NULL);
1744
1745     moveZoneAnimation.name = config->ConfigGetString("switchzone",
1746                                                      "animation",
1747                                                      ICO_HS_ANIMATION_FADE);
1748     moveZoneAnimation.time = config->ConfigGetInteger("switchzone",
1749                                                       "animatime", 400);
1750     // debug log
1751     ICO_DBG("moveZoneName=%s animation=%s time=%d",
1752             moveZoneName, moveZoneAnimation.name, moveZoneAnimation.time);
1753
1754     // AUL Listen Signal set(launch/dead)
1755     initAulListenXSignal();
1756
1757     // application history class init. before call launchApps
1758     InitializeAppHistory();
1759
1760     /* application history launch */
1761     t_launcApps_data* x = new t_launcApps_data;
1762     CicoHSCmdOpts* cmdOpts = CicoHSCmdOpts::getInstance();
1763     x->filePath  = cmdOpts->getHistoryFilePath();
1764     x->filePathD = cmdOpts->getDefaultHistoryFilePath();
1765     x->hs        = this;
1766     ecore_timer_add(0.01, launchApps, x);
1767
1768     /* Create BackGround window */
1769     CreateBackWindow();
1770
1771     /* Create SwipeInput window */
1772     CicoHSSwipeTouch::Initialize(hs_instance->ctl_bar_window, hs_instance->m_appHis,
1773                                  full_width, full_height);
1774     CreateSwipeInputWindow();
1775
1776     /* Create ControlBar window */
1777     CreateControlBarWindow();
1778
1779     /* Create Menu window       */
1780     CreateMenuWindow();
1781
1782     /*Show Home Screen*/
1783     ShowHomeScreenLayer();
1784
1785     ICO_TRA("CicoHomeScreen::StartHomeScreen Leave");
1786     return 0;
1787 }
1788
1789 /*--------------------------------------------------------------------------*/
1790 /**
1791  * @brief   CicoHomeScreen::GetMode
1792  *          Get status
1793  *
1794  * @param[in]   mode status
1795  * @return      none
1796  */
1797 /*--------------------------------------------------------------------------*/
1798 int
1799 CicoHomeScreen::GetMode(void)
1800 {
1801     return mode;
1802 }
1803
1804 /*--------------------------------------------------------------------------*/
1805 /**
1806  * @brief   CicoHomeScreen::SetMode
1807  *          Set status
1808  *
1809  * @param[in]   mode status
1810  * @return      none
1811  */
1812 /*--------------------------------------------------------------------------*/
1813 void
1814 CicoHomeScreen::SetMode(int mode)
1815 {
1816     this->mode = mode;
1817 }
1818
1819 /*--------------------------------------------------------------------------*/
1820 /**
1821  * @brief   CicoHomeScreen::ChangeMode
1822  *          Change status
1823  *
1824  * @param[in]   none
1825  * @return      none
1826  */
1827 /*--------------------------------------------------------------------------*/
1828 void
1829 CicoHomeScreen::ChangeMode(int pattern)
1830 {
1831     int idx;
1832
1833     if (hs_instance->menu_window == NULL)   {
1834         return;
1835     }
1836
1837     if (hs_instance->GetMode() == ICO_HS_MODE_MENU) {
1838         ico_syc_animation_t animation;
1839         ICO_DBG("CicoHomeScreen::ChangeMode: MENU->APP");
1840         if (pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE)  {
1841             animation.name = ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1842         }
1843         else    {
1844             animation.name = ICO_HS_MENU_HIDE_ANIMATION_FADE;
1845         }
1846         animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1847         hs_instance->menu_window->Hide(&animation);
1848         for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++)    {
1849             hs_instance->swipe_input_windows[idx]->Show();
1850         }
1851         hs_instance->SetMode(ICO_HS_MODE_APPLICATION);
1852         CicoHSAppInfo *appinfo = hs_instance->GetActiveAppInfo();
1853         if (NULL != appinfo) {
1854             ico_syc_change_active(appinfo->GetAppId(), appinfo->GetLastSurface());
1855         }
1856     }
1857     else if (hs_instance->GetMode() ==ICO_HS_MODE_APPLICATION)  {
1858         ico_syc_animation_t animation;
1859         ICO_DBG("CicoHomeScreen::ChangeMode: APP->MENU");
1860         if (pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE)  {
1861             animation.name = ICO_HS_MENU_SHOW_ANIMATION_SLIDE;
1862         }
1863         else    {
1864             animation.name = ICO_HS_MENU_SHOW_ANIMATION_FADE;
1865         }
1866         animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1867         hs_instance->menu_window->Show(&animation);
1868         for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++)    {
1869             hs_instance->swipe_input_windows[idx]->Hide();
1870         }
1871         hs_instance->SetMode(ICO_HS_MODE_MENU);
1872     }
1873 }
1874
1875 /*--------------------------------------------------------------------------*/
1876 /**
1877  * @brief   CicoHomeScreen::ExecuteApp
1878  *          execute application
1879  *
1880  * @param[in]   appid
1881  * @return      none
1882  */
1883 /*--------------------------------------------------------------------------*/
1884 void
1885 CicoHomeScreen::ExecuteApp(const char*appid)
1886 {
1887     hs_instance->ExecuteApp_i(appid);
1888 }
1889
1890 /*--------------------------------------------------------------------------*/
1891 /**
1892  * @brief   CicoHomeScreen::TerminateApp
1893  *          teminate application
1894  *
1895  * @param[in]   appid
1896  * @return      none
1897  */
1898 /*--------------------------------------------------------------------------*/
1899 void
1900 CicoHomeScreen::TerminateApp(const char*appid)
1901 {
1902     hs_instance->TerminateApp_i(appid);
1903 }
1904
1905 /*--------------------------------------------------------------------------*/
1906 /**
1907  * @brief   CicoHomeScreen::setActiveApp
1908  *          active(touch operate app) notice
1909  *
1910  * @param[in]   appid
1911  * @return      none
1912  */
1913 /*--------------------------------------------------------------------------*/
1914 void
1915 CicoHomeScreen::setActiveApp(const char* appid)
1916 {
1917     if ((NULL == appid) || (0 == appid) || (0 == strlen(appid))) {
1918         return;
1919     }
1920     if (NULL != m_appHis) {
1921         m_appHis->activeApp(appid);
1922     }
1923 }
1924
1925 /*--------------------------------------------------------------------------*/
1926 /**
1927  * @brief   CicoHomeScreen::SetNightMode
1928  *          set night mode theme
1929  *
1930  * @param[in]   data    user data
1931  */
1932 /*--------------------------------------------------------------------------*/
1933 void
1934 CicoHomeScreen::SetNightMode(void* data)
1935 {
1936     ICO_TRA("CicoHomeScreen::SetNightMode Enter");
1937    // night mode action
1938     hs_instance->ctl_bar_window->SetNightMode();
1939     hs_instance->menu_window->SetNightMode();
1940     ICO_TRA("CicoHomeScreen::SetNightMode Leave");
1941 }
1942
1943 /*--------------------------------------------------------------------------*/
1944 /**
1945  * @brief   CicoHomeScreen::SetRegulation
1946  *          regulation action and set regualtion theme
1947  *
1948  * @param[in]   data    user data
1949  */
1950 /*--------------------------------------------------------------------------*/
1951 void
1952 CicoHomeScreen::SetRegulation(void* data)
1953 {
1954     ICO_TRA("CicoHomeScreen::SetRegulation Enter");
1955     // window control
1956     hs_instance->controlRegulation();
1957     // regulation action
1958     hs_instance->ctl_bar_window->SetRegulation();
1959     ico_syc_animation_t animation;
1960     animation.name = ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1961     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1962     hs_instance->menu_window->Hide(&animation);
1963
1964     // force focus change
1965     if (false == CicoHSSystemState::getInstance()->getRegulation()) {
1966         CicoHSAppInfo *active_appinfo = hs_instance->GetActiveAppInfo();
1967         if (NULL != active_appinfo) {
1968             ico_syc_change_active(active_appinfo->GetAppId(),
1969                                   active_appinfo->GetLastSurface());
1970             ico_syc_change_active(active_appinfo->GetAppId(), 0);
1971         }
1972     }
1973     else {
1974         if (NULL != hs_instance->ctl_bar_window) {
1975             const char *ctl_bar_appid = hs_instance->ctl_bar_window->GetAppId();
1976             int ctl_bar_surface = hs_instance->ctl_bar_window->GetSurfaceId();
1977             ico_syc_change_active(ctl_bar_appid, ctl_bar_surface);
1978             ico_syc_change_active(ctl_bar_appid, 0);
1979         }
1980     }
1981
1982     ICO_TRA("CicoHomeScreen::SetRegulation Leave");
1983 }
1984
1985 /*--------------------------------------------------------------------------*/
1986 /**
1987  * @brief   CicoHomeScreen::RenewAppInfoList_i
1988  *          renewal application info list
1989  *
1990  * @param[in]   none
1991  * @return      none
1992  */
1993 /*--------------------------------------------------------------------------*/
1994 void
1995 CicoHomeScreen::RenewAppInfoList_i(void)
1996 {
1997     int ii = 0;
1998     int kk = 0;
1999     CicoHSAppInfo *tmp_apps_info[ICO_HS_MAX_APP_NUM];
2000     int tmp_application_num = 0;
2001     const char *appid_p = 0;
2002
2003     for(ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++){
2004         tmp_apps_info[ii] = NULL;
2005     }
2006
2007     /* get APP information*/
2008     std::vector<CicoAilItems> aillist = life_cycle_controller->getAilList();
2009
2010     /*create instance*/
2011     for ( ii = 0;
2012          (ii < (int)aillist.size()) && (ii < ICO_HS_MAX_APP_NUM);
2013          ii++)  {
2014         ICO_DBG("aillist[%d].m_appid.c_str() = %s",
2015                  ii, aillist[ii].m_appid.c_str());
2016
2017         for (kk = 0; kk < ICO_HS_MAX_APP_NUM; kk++) {
2018             if (apps_info[kk] == NULL) {
2019                 continue;
2020             }
2021
2022             if (strcmp(aillist[ii].m_appid.c_str(),
2023                 apps_info[kk]->GetAppId()) == 0) {
2024
2025                 tmp_apps_info[ii] = apps_info[kk];
2026                 ICO_DBG("shift aillist[%d].m_appid.c_str() = %s",
2027                          ii, aillist[ii].m_appid.c_str());
2028                 break;
2029             }
2030         }
2031         if (kk == ICO_HS_MAX_APP_NUM) {
2032             tmp_apps_info[ii] = new CicoHSAppInfo(aillist[ii].m_appid.c_str());
2033             ICO_DBG("create aillist[%d].m_appid.c_str() = %s",
2034                      ii, aillist[ii].m_appid.c_str());
2035         }
2036         tmp_application_num++;
2037     }
2038
2039     /* delete instance */
2040     for (ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
2041         if (apps_info[ii] == NULL) {
2042             continue;
2043         }
2044         appid_p = apps_info[ii]->GetAppId();
2045         for ( kk = 0; kk < tmp_application_num; kk++) {
2046             if (strcmp(appid_p, tmp_apps_info[kk]->GetAppId()) == 0) {
2047                 break;
2048             }
2049         }
2050         if (kk == tmp_application_num) {
2051             delete apps_info[ii];
2052             ICO_DBG("delete apps_info[%d]->GetAppId() = %s",
2053                     ii, appid_p);
2054         }
2055     }
2056
2057     /* set apps info */
2058     for ( ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
2059         apps_info[ii] = tmp_apps_info[ii];
2060     }
2061
2062     application_num = tmp_application_num;
2063 }
2064
2065 /*--------------------------------------------------------------------------*/
2066 /**
2067  * @brief   CicoHomeScreen::RenewAppInfoList
2068  *          renewal appinfolist
2069  *
2070  * @param[in]   none
2071  * @return      none
2072  */
2073 /*--------------------------------------------------------------------------*/
2074 void
2075 CicoHomeScreen::RenewAppInfoList(void)
2076 {
2077     ICO_TRA("CicoHomeScreen::RenewAppInfoList Enter");
2078     hs_instance->RenewAppInfoList_i();
2079     ICO_TRA("CicoHomeScreen::RenewAppInfoList Leave");
2080 }
2081
2082 /*--------------------------------------------------------------------------*/
2083 /**
2084  * @brief   CicoHomeScreen::startupCheckAdd
2085  *          start-up application infomation add
2086  *
2087  * @param[in]  pid
2088  * @param[in]  appid
2089  * @return     none
2090  */
2091 /*--------------------------------------------------------------------------*/
2092 void CicoHomeScreen::startupCheckAdd(int pid, const std::string& appid,
2093                                      bool bSubDisp)
2094 {
2095     if (NULL != m_appHis) {
2096         m_appHis->startupCheckAdd(pid, appid, bSubDisp);
2097     }
2098 }
2099
2100 /*--------------------------------------------------------------------------*/
2101 /**
2102  * @brief   CicoHomeScreen::startupCheck
2103  *          start-up application check
2104  *
2105  * @param[in]  appid check target
2106  */
2107 /*--------------------------------------------------------------------------*/
2108 void CicoHomeScreen::startupCheck(const char* appid)
2109 {
2110     ICO_TRA("CicoHomeScreen::startupCheck Enter");
2111     if (NULL == life_cycle_controller) {
2112         ICO_ERR("life_cycle_controller is null");
2113         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2114         return;
2115     }
2116     if (NULL == m_appHis) {
2117         ICO_ERR("m_appHis is null");
2118         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2119         return;
2120     }
2121     if (false == m_appHis->isStartupChecking()) {
2122         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2123         return;
2124     }
2125     m_appHis->update_appid();
2126     m_appHis->startupEntryFinish(appid);
2127     if (false == m_appHis->isFinish()) {
2128         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2129         return;
2130     }
2131     finishStartup();
2132     ICO_TRA("CicoHomeScreen::startupCheck Leave");
2133 }
2134
2135 /*--------------------------------------------------------------------------*/
2136 /**
2137  * @brief   CicoHomeScreen::finishStartup
2138  *          start-up application check
2139  *
2140  * @param[in]  appid check target
2141  */
2142 /*--------------------------------------------------------------------------*/
2143
2144 void CicoHomeScreen::finishStartup(void)
2145 {
2146     ICO_TRA("CicoHomeScreen::finishStartup Enter");
2147
2148     string last = m_appHis->getLastStartupAppid();
2149     const string& subDisp = m_appHis->getSubDispAppid();
2150
2151     list<string> h = m_appHis->getAppHistory();
2152     // last appid is empty then get new last appid
2153     if (true == last.empty()) {
2154         list<string>::iterator it_h = h.begin();
2155         while (it_h != h.end()) {
2156             if (0 != subDisp.compare(*it_h)) {
2157                 last = *it_h;
2158             }
2159             ++it_h;
2160         }
2161     }
2162
2163     list<string>::reverse_iterator rit_h = h.rbegin();
2164     while(rit_h != h.rend()) {
2165         CicoHSAppInfo *ai = GetAppInfo((*rit_h).c_str());
2166         if (ai == NULL) {
2167             ++rit_h;
2168             continue;
2169         }
2170         ICO_DBG("Raise %s", (*rit_h).c_str());
2171         {
2172             const char* appid = ai->GetAppId();
2173             int surface = ai->GetLastSurface();
2174             if ((0 != last.compare(appid)) && (0 != subDisp.compare(appid))) {
2175                 ico_syc_show(appid, surface, NULL);
2176                 ico_syc_hide(appid, surface, NULL);
2177             }
2178         }
2179         ++rit_h;
2180     }
2181
2182     CicoHSAppInfo *ai = GetAppInfo(subDisp.c_str());
2183     if (ai != NULL) {
2184         requestChangeZone(ai);
2185     }
2186
2187     ai = GetAppInfo(last.c_str());
2188     if (ai != NULL) {
2189         const char* appid = ai->GetAppId();
2190         int surface = ai->GetLastSurface();
2191         ico_syc_show(appid, surface, NULL);
2192         ico_syc_change_active(appid, surface);
2193         hs_instance->SetActiveAppInfo(appid);
2194     }
2195
2196     m_appHis->stopStartupCheck();
2197     ICO_TRA("CicoHomeScreen::finishStartup Leave");
2198 }
2199
2200 /*--------------------------------------------------------------------------*/
2201 /**
2202  * @brief   CicoHomeScreen::readStartupApp
2203  *          read start-up application data
2204  *
2205  * @param[in]  appid check target
2206  */
2207 /*--------------------------------------------------------------------------*/
2208 void CicoHomeScreen::readStartupApp(std::vector<pairAppidSubd>& apps)
2209 {
2210     ICO_TRA("CicoHomeScreen::readStartupApp Enter");
2211     if (NULL == m_appHis) {
2212         apps.clear();
2213     }
2214     else {
2215         m_appHis->readAppHistory(apps);
2216     }
2217     ICO_TRA("CicoHomeScreen::readStartupApp Leave(%d)", (int)apps.size());
2218     return;
2219 }
2220
2221 /*--------------------------------------------------------------------------*/
2222 /**
2223  * @brief   CicoHomeScreen::requestHideAppid
2224  *          request Hide appid
2225  *
2226  * @param  app appid
2227  */
2228 /*--------------------------------------------------------------------------*/
2229 void CicoHomeScreen::requestHideAppid(const std::string& app)
2230 {
2231     const char* appid = app.c_str();
2232     ICO_TRA("start %s", appid);
2233     CicoHSAppInfo *ai = GetAppInfo(appid);
2234     if (NULL == ai) {
2235         ICO_DBG("end %d", appid);
2236         return;
2237     }
2238     int surface = ai->GetLastSurface();
2239     ico_syc_hide(appid, surface, NULL);
2240     ICO_TRA("end");
2241 }
2242
2243 /*--------------------------------------------------------------------------*/
2244 /**
2245  * @brief   CicoHomeScreen::requestShowAppid
2246  *          request Show appid
2247  *
2248  * @param  app appid
2249  */
2250 /*--------------------------------------------------------------------------*/
2251 void CicoHomeScreen::requestShowAppid(const std::string& app)
2252 {
2253     const char* appid = app.c_str();
2254     ICO_TRA("start %s", appid);
2255     CicoHSAppInfo *ai = GetAppInfo(appid);
2256     if (NULL == ai) {
2257         ICO_DBG("end %d", appid);
2258         return;
2259     }
2260     int surface = ai->GetLastSurface();
2261     ico_syc_show(appid, surface, NULL);
2262     ICO_TRA("end");
2263 }
2264
2265 /*--------------------------------------------------------------------------*/
2266 /**
2267  * @brief   CicoHomeScreen::requestActivationAppid
2268  *          request Activation
2269  *
2270  * @param  app appid
2271  */
2272 /*--------------------------------------------------------------------------*/
2273 void CicoHomeScreen::requestActivationAppid(const std::string& app)
2274 {
2275     const char* appid = app.c_str();
2276     ICO_TRA("CicoHomeScreen::requestActivationAppid Enter(%s)", appid);
2277     CicoHSAppInfo *ai = GetAppInfo(appid);
2278     if (NULL == ai) {
2279         ICO_DBG("end %d", appid);
2280         return;
2281     }
2282     int surface = ai->GetLastSurface();
2283     hs_instance->SetActiveAppInfo(app.c_str());
2284     ico_syc_show(appid, surface, NULL);
2285     ico_syc_change_active(appid, surface);
2286     ICO_TRA("CicoHomeScreen::requestActivationAppid Leave");
2287 }
2288
2289 /*--------------------------------------------------------------------------*/
2290 /**
2291  * @brief   CicoHomeScreen::controlRegulation
2292  *          controlRegulation
2293  *
2294  * @param  reqStt true / false
2295  */
2296 /*--------------------------------------------------------------------------*/
2297 void CicoHomeScreen::controlRegulation(bool regStt)
2298 {
2299     ICO_TRA("CicoHomeScreen::controlRegulation Enter(%s)",
2300             regStt? "true": "false");
2301     if (NULL == m_appHis) {
2302         ICO_ERR("m_appHis is null");
2303         ICO_TRA("CicoHomeScreen::controlRegulation Leave");
2304         return;
2305     }
2306     const string& wapp = m_appHis->getSelectApp(); // select appid get
2307     if (false == wapp.empty()) { // select appid nothing
2308         const string& napp = m_appHis->getNearHistory(); // history top appid get
2309         if (0 != wapp.compare(napp)) { // history top, wait app is Eqale
2310             requestHideAppid(napp);
2311             requestActivationAppid(wapp);
2312             m_appHis->moveHistoryHead(wapp);
2313         }
2314         m_appHis->clearSelectApp(); // select appid clear
2315         m_appHis->homeSwipe();
2316     }
2317     ICO_TRA("CicoHomeScreen::controlRegulation Leave");
2318 }
2319
2320 /*--------------------------------------------------------------------------*/
2321 /**
2322  * @brief   CicoHomeScreen::ActivationUpdate
2323  *          history update by swipe app
2324  *
2325  * @return bool
2326  * @retval true history update
2327  * @retval false no history updath
2328  */
2329 /*--------------------------------------------------------------------------*/
2330 bool
2331 CicoHomeScreen::ActivationUpdate(void)
2332 {
2333     return hs_instance->ActivationUpdate_i();
2334 }
2335
2336 /*--------------------------------------------------------------------------*/
2337 /**
2338  * @brief   CicoHomeScreen::ActivationUpdate_i
2339  *          history update by swipe app
2340  *
2341  * @return bool
2342  * @retval true history update
2343  * @retval false no history updath
2344  */
2345 /*--------------------------------------------------------------------------*/
2346 bool
2347 CicoHomeScreen::ActivationUpdate_i(void)
2348 {
2349     ICO_TRA("CicoHomeScreen::ActivationUpdate_i Enter");
2350     if (NULL == m_appHis) {
2351         ICO_ERR("m_appHis is null");
2352         ICO_TRA("CicoHomeScreen::ActivationUpdate_i Leave(false)");
2353         return false;
2354     }
2355     bool bR = false;
2356     const string& wapp = m_appHis->getSelectApp(); // select appid get
2357     if (false == wapp.empty()) { // select appid nothing
2358         const string& napp = m_appHis->getNearHistory(); // history top appid get
2359         if (0 != wapp.compare(napp)) { // history top, wait app is Eqale
2360             requestActivationAppid(wapp);
2361             m_appHis->moveHistoryHead(wapp);
2362             bR = true;
2363         }
2364         m_appHis->clearSelectApp(); // select appid clear
2365         m_appHis->homeSwipe();
2366     }
2367     ICO_TRA("CicoHomeScreen::ActivationUpdate_i Leave(%s)",
2368             bR? "true": "false");
2369     return bR;
2370 }
2371
2372 /*--------------------------------------------------------------------------*/
2373 /**
2374  * @brief   CicoHomeScreen::ShowApp_i
2375  *          show app
2376  *
2377  * @param  app appid
2378  */
2379 /*--------------------------------------------------------------------------*/
2380 void
2381 CicoHomeScreen::ShowApp_i(const std::string& app)
2382 {
2383     CicoHSAppInfo *appinfo = GetAppInfo(app.c_str());
2384     if (appinfo == NULL)    {
2385         ICO_TRA("end get appinfo is NULL");
2386         return;
2387     }
2388
2389     ico_syc_animation_t animation;
2390     animation.name = ICO_HS_MENU_HIDE_ANIMATION_FADE;
2391     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
2392
2393     ico_syc_show(appinfo->GetAppId(), appinfo->GetLastSurface(), &animation);
2394     ico_syc_change_active(appinfo->GetAppId(), appinfo->GetLastSurface());
2395     hs_instance->SetActiveAppInfo(appinfo->GetAppId());
2396     //raise
2397 //    RaiseApplicationWindow(appinfo->GetAppId(),
2398 //                           appinfo->GetLastSurface());
2399     ICO_DBG("raise app %s", app.c_str());
2400     m_appHis->moveHistoryHead(app);
2401 }
2402
2403 /*--------------------------------------------------------------------------*/
2404 /**
2405  * @brief   CicoHomeScreen::ShowApp
2406  *          show app
2407  *
2408  * @param  app appid
2409  */
2410 /*--------------------------------------------------------------------------*/
2411 void
2412 CicoHomeScreen::ShowApp(const std::string& app)
2413 {
2414     hs_instance->ShowApp_i(app);
2415 }
2416
2417 /*--------------------------------------------------------------------------*/
2418 /**
2419  * @brief   CicoHomeScreen::HideAppid
2420  *          hide app
2421  *
2422  * @param  app appid
2423  */
2424 /*--------------------------------------------------------------------------*/
2425 void
2426 CicoHomeScreen::HideApp(const std::string& app)
2427 {
2428     const char* appid = app.c_str();
2429     ICO_TRA("start %s", appid);
2430     CicoHSAppInfo *ai = GetAppInfo(appid);
2431     if (NULL == ai) {
2432         ICO_DBG("end %d", appid);
2433         return;
2434     }
2435
2436     ico_syc_animation_t animation;
2437     animation.name = ICO_HS_MENU_HIDE_ANIMATION_FADE;
2438     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
2439
2440     int surface = ai->GetLastSurface();
2441     ico_syc_hide(appid, surface, &animation);
2442     ICO_TRA("end");
2443 }
2444
2445 /*--------------------------------------------------------------------------*/
2446 /**
2447  * @brief   CicoHomeScreen::MoveApp
2448  *          move app
2449  *
2450  * @param  app appid
2451  * @param  zone zone
2452  */
2453 /*--------------------------------------------------------------------------*/
2454 void
2455 CicoHomeScreen::MoveApp(const std::string& app, const std::string& zone)
2456 {
2457     CicoHSAppInfo *appinfo = GetAppInfo(app.c_str());
2458     if ((CicoHSAppInfo*)0 == appinfo) {
2459         ICO_DBG("GetAppInfo(%s) is NULL" , app.c_str());
2460         return;
2461     }
2462
2463     int surface = appinfo->GetLastSurface();
2464     ico_hs_window_info* wininfo = appinfo->GetWindowInfobySurface(surface);
2465     if (wininfo)    {
2466         int layer = HS_LAYER_APPLICATION;
2467         const char *dispzone = zone.c_str();
2468         ico_syc_win_move_t move;
2469         move.zone   = dispzone;
2470         move.layer  = layer;
2471         move.pos_x  = 0;
2472         move.pos_y  = 0;
2473         move.width  = 0;
2474         move.height = 0;
2475
2476         ico_syc_move(wininfo->appid, wininfo->surface, &move,
2477                      &hs_instance->moveZoneAnimation);
2478     }
2479 }
2480 // vim: set expandtab ts=4 sw=4: