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