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