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     int     pos_y, swipe_height;
1540
1541     ICO_DBG("CicoHomeScreen::CreateSwipeInputWindow: start");
1542     /* cullentry SwipeInput windows is fixed size   */
1543     pos_y = ICO_HS_WINDOW_POS_Y + ICO_HS_SWIPE_TOUCH_DISTANCE_TOP;
1544     swipe_height = full_height - pos_y - ICO_HS_SWIPE_TOUCH_DISTANCE_BOTTOM;
1545
1546     /* left side window     */
1547     swipe_input_windows[0] = new CicoHSSwipeInputWindow();
1548     swipe_input_windows[0]->
1549             CreateSwipeInputWindow(ICO_HS_WINDOW_POS_X, pos_y,
1550                                    ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, swipe_height,
1551                                    "left");
1552     swipe_input_windows[0]->ShowWindow();
1553
1554     /* right side window    */
1555     swipe_input_windows[1] = new CicoHSSwipeInputWindow();
1556     swipe_input_windows[1]->
1557             CreateSwipeInputWindow(full_width - ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, pos_y,
1558                                    ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, swipe_height,
1559                                    "right");
1560     swipe_input_windows[1]->ShowWindow();
1561
1562 #if 0       /* currently not support(not fix specification) */
1563     /* buttom side window   */
1564     swipe_input_windows[2] = new CicoHSSwipeInputWindow();
1565     swipe_input_windows[2]->
1566             CreateSwipeInputWindow(ICO_HS_WINDOW_POS_X,
1567                                    full_height - ICO_HS_SWIPE_TOUCH_SWIPE_HEIGHT,
1568                                    full_width, ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, "buttom");
1569
1570     swipe_input_windows[2]->ShowWindow();
1571     num_swipe_input_windows = 3;
1572 #else
1573     num_swipe_input_windows = 2;
1574 #endif
1575     ICO_DBG("CicoHomeScreen::CreateSwipeInputWindow: end");
1576 }
1577
1578 /*--------------------------------------------------------------------------*/
1579 /**
1580  * @brief   CicoHomeScreen::DeleteSwipeInputWindow
1581  *          delete swipe input windows
1582  *
1583  * @param[in]   none
1584  * @return      none
1585  */
1586 /*--------------------------------------------------------------------------*/
1587 void
1588 CicoHomeScreen::DeleteSwipeInputWindow(void)
1589 {
1590     int idx;
1591
1592     for (idx = 0; idx < num_swipe_input_windows; idx++) {
1593         if (swipe_input_windows[idx])   {
1594             swipe_input_windows[idx]->FreeSwipeInputWindow();
1595             delete swipe_input_windows[idx];
1596             swipe_input_windows[idx] = NULL;
1597         }
1598     }
1599     num_swipe_input_windows = 0;
1600 }
1601
1602 /*--------------------------------------------------------------------------*/
1603 /**
1604  * @brief   launch applications
1605  *
1606  * @param   filepath  start applications list file path
1607  * @param   filepathD defalt start applications list file path
1608  * @return  bool
1609  * @retval  true  success
1610  * @retval  false fail
1611  */
1612 /*--------------------------------------------------------------------------*/
1613 static Eina_Bool launchApps(void* data)
1614 {
1615     ICO_DBG("start");
1616     launcApps_data_t* x = (launcApps_data_t*) data;
1617     if ((NULL == x) || (NULL == x->hs)) {
1618         ICO_DBG("end fail");
1619         return ECORE_CALLBACK_CANCEL;
1620     }
1621
1622     vector<pairAppidSubd> apps;
1623     x->hs->readStartupApp(apps);
1624
1625     int sz = apps.size();
1626     for (int i =sz; i > 0; i--) {
1627         string appid = apps[i-1].first;
1628         bool bFLAG = apps[i-1].second;
1629         const char* app = appid.c_str();
1630         ICO_PRF("CHG_APP_STA 1.request app=%s", app);
1631         int pid = aul_launch_app(appid.c_str(), NULL);
1632         ICO_DBG("            1.request [%d]%d:%s:%d", i, pid, app, (int)bFLAG);
1633         if ((0 < pid) && (NULL != x->hs)) {
1634             x->hs->startupCheckAdd(pid, appid, bFLAG);
1635         }
1636     }
1637     ICO_DBG("end success");
1638     return ECORE_CALLBACK_CANCEL;
1639 }
1640
1641 /*--------------------------------------------------------------------------*/
1642 /**
1643  * @brief   CicoHomeScreen::StartHomeScreen
1644  *          start home screen
1645  *
1646  * @param[in]   none
1647  * @return      none
1648  */
1649 /*--------------------------------------------------------------------------*/
1650 int
1651 CicoHomeScreen::StartHomeScreen(int orientation)
1652 {
1653     int     retry;
1654
1655     ICO_TRA("CicoHomeScreen::StartHomeScreen Enter");
1656
1657     /*save instance pointer */
1658     hs_instance = this;
1659
1660     /*config copy*/
1661     this->config = new CicoGKeyFileConfig();
1662     this->config->Initialize(ICO_HOMESCREEN_CONFIG_FILE);
1663
1664     /* init home screen soud */
1665     CicoSound::GetInstance()->Initialize(this->config);
1666
1667     /*Get application info*/
1668     CreateAppInfoList();
1669
1670     /* get pkg name (home screen,status bar,on screen)*/
1671     char *pkg;
1672     ICO_DBG("CicoHomeSceen::StartHomeScreen: %s: %s",
1673             getenv("HOME"), getenv("PKG_NAME"));
1674     pkg = getenv("PKG_NAME");
1675     memset(hs_package_name, 0, ICO_HS_MAX_PROCESS_NAME);
1676     if (pkg)    {
1677         strncpy(hs_package_name, pkg, ICO_HS_MAX_PROCESS_NAME);
1678     }
1679     else    {
1680         strncpy(hs_package_name, ICO_HS_PROC_DEFAULT_HOMESCREEN,
1681                 ICO_HS_MAX_PROCESS_NAME);
1682     }
1683
1684     /* create application control instance */
1685     CicoHSAppControl *m_appctrl = CicoHSAppControl::getInstance();
1686
1687     /* create server instance */
1688     CicoHSServer *server = CicoHSServer::getInstance();
1689     server->setAppCtrl(m_appctrl);
1690     server->startup(10001, (const char*)"ico_hs_protocol");
1691
1692     /* Initialize WindowController */
1693     CicoHSWindowController::Initialize();
1694     ICO_DBG("CicoHomeScreen::StartHomeScreen: window controller initialized");
1695
1696     ICO_DBG("CicoHomeScreen::StartHomeScreen: start connect to systemcontroller");
1697     ico_syc_connect(EventCallBack,NULL);
1698     for (retry = 0; retry < (2000/10); retry++) {
1699         ico_syc_service();
1700         if (ico_syc_isconnect())    break;
1701         usleep(10*1000);
1702     }
1703     ICO_DBG("CicoHomeScreen::StartHomeScreen: end connect to systemcontroller");
1704
1705     /*initialize system controller*/
1706     /*my info*/
1707     ICO_DBG("CicoHomeScreen::StartHomeScreen: get package name %s",hs_package_name);
1708     hs_app_info = GetAppInfo(hs_package_name);
1709
1710     /*start home statusbar and onscreen*/
1711     StartRelations();
1712     ICO_DBG("CicoHomeScreen::StartHomeScreen: start relation apps");
1713
1714     /* Get screen size */
1715     CicoHSWindowController::GetFullScreenSize(orientation,
1716                                               &full_width,&full_height);
1717
1718     ICO_DBG("full screen size x=%d y=%d",full_width,full_height);
1719
1720     /* MenuScreen Window Size */
1721     menu_width = full_width;
1722     menu_height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
1723                   ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1724
1725     /* BackGround Window Size */
1726     bg_width  = full_width;
1727     bg_height = full_height;
1728
1729     /* Control Bar Window Size */
1730     ctl_bar_width  = full_width;
1731     ctl_bar_height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1732
1733     // load switch display zone config
1734     moveZoneName = config->ConfigGetString("switchzone", "movezone", NULL);
1735
1736     moveZoneAnimation.name = (char*)config->ConfigGetString("switchzone",
1737                                                             "animation",
1738                                                             ICO_HS_ANIMATION_FADE);
1739     moveZoneAnimation.time = config->ConfigGetInteger("switchzone",
1740                                                       "animatime", 400);
1741     // debug log
1742     ICO_DBG("moveZoneName=%s animation=%s time=%d",
1743             moveZoneName, moveZoneAnimation.name, moveZoneAnimation.time);
1744
1745     // AUL Listen Signal set(launch/dead)
1746     initAulListenXSignal();
1747
1748     // application history class init. before call launchApps
1749     InitializeAppHistory();
1750
1751     /* application history launch */
1752     t_launcApps_data* x = new t_launcApps_data;
1753     CicoHSCmdOpts* cmdOpts = CicoHSCmdOpts::getInstance();
1754     x->filePath  = cmdOpts->getHistoryFilePath();
1755     x->filePathD = cmdOpts->getDefaultHistoryFilePath();
1756     x->hs        = this;
1757     ecore_timer_add(0.01, launchApps, x);
1758
1759     /* Create BackGround window */
1760     CreateBackWindow();
1761
1762     /* Create SwipeInput window */
1763     CicoHSSwipeTouch::Initialize(hs_instance->ctl_bar_window, hs_instance->m_appHis,
1764                                  full_width, full_height);
1765     CreateSwipeInputWindow();
1766
1767     /* Create ControlBar window */
1768     CreateControlBarWindow();
1769
1770     /* Create Menu window       */
1771     CreateMenuWindow();
1772
1773     /*Show Home Screen*/
1774     ShowHomeScreenLayer();
1775
1776     ICO_TRA("CicoHomeScreen::StartHomeScreen Leave");
1777     return 0;
1778 }
1779
1780 /*--------------------------------------------------------------------------*/
1781 /**
1782  * @brief   CicoHomeScreen::GetMode
1783  *          Get status
1784  *
1785  * @param[in]   mode status
1786  * @return      none
1787  */
1788 /*--------------------------------------------------------------------------*/
1789 int
1790 CicoHomeScreen::GetMode(void)
1791 {
1792     return mode;
1793 }
1794
1795 /*--------------------------------------------------------------------------*/
1796 /**
1797  * @brief   CicoHomeScreen::SetMode
1798  *          Set status
1799  *
1800  * @param[in]   mode status
1801  * @return      none
1802  */
1803 /*--------------------------------------------------------------------------*/
1804 void
1805 CicoHomeScreen::SetMode(int mode)
1806 {
1807     this->mode = mode;
1808 }
1809
1810 /*--------------------------------------------------------------------------*/
1811 /**
1812  * @brief   CicoHomeScreen::ChangeMode
1813  *          Change status
1814  *
1815  * @param[in]   none
1816  * @return      none
1817  */
1818 /*--------------------------------------------------------------------------*/
1819 void
1820 CicoHomeScreen::ChangeMode(int pattern)
1821 {
1822     int idx;
1823
1824     if (hs_instance->menu_window == NULL)   {
1825         return;
1826     }
1827
1828     if (hs_instance->GetMode() == ICO_HS_MODE_MENU) {
1829         ico_syc_animation_t animation;
1830         ICO_DBG("CicoHomeScreen::ChangeMode: MENU->APP");
1831         if (pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE)  {
1832             animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1833         }
1834         else    {
1835             animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_FADE;
1836         }
1837         animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1838         hs_instance->menu_window->Hide(&animation);
1839         for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++)    {
1840             hs_instance->swipe_input_windows[idx]->Show();
1841         }
1842         hs_instance->SetMode(ICO_HS_MODE_APPLICATION);
1843         CicoHSAppInfo *appinfo = hs_instance->GetActiveAppInfo();
1844         if (NULL != appinfo) {
1845             ico_syc_change_active(appinfo->GetAppId(), appinfo->GetLastSurface());
1846         }
1847     }
1848     else if (hs_instance->GetMode() ==ICO_HS_MODE_APPLICATION)  {
1849         ico_syc_animation_t animation;
1850         ICO_DBG("CicoHomeScreen::ChangeMode: APP->MENU");
1851         if (pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE)  {
1852             animation.name = (char*)ICO_HS_MENU_SHOW_ANIMATION_SLIDE;
1853         }
1854         else    {
1855             animation.name = (char*)ICO_HS_MENU_SHOW_ANIMATION_FADE;
1856         }
1857         animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1858         hs_instance->menu_window->Show(&animation);
1859         for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++)    {
1860             hs_instance->swipe_input_windows[idx]->Hide();
1861         }
1862         hs_instance->SetMode(ICO_HS_MODE_MENU);
1863     }
1864 }
1865
1866 /*--------------------------------------------------------------------------*/
1867 /**
1868  * @brief   CicoHomeScreen::ExecuteApp
1869  *          execute application
1870  *
1871  * @param[in]   appid
1872  * @return      none
1873  */
1874 /*--------------------------------------------------------------------------*/
1875 void
1876 CicoHomeScreen::ExecuteApp(const char*appid)
1877 {
1878     hs_instance->ExecuteApp_i(appid);
1879 }
1880
1881 /*--------------------------------------------------------------------------*/
1882 /**
1883  * @brief   CicoHomeScreen::TerminateApp
1884  *          teminate application
1885  *
1886  * @param[in]   appid
1887  * @return      none
1888  */
1889 /*--------------------------------------------------------------------------*/
1890 void
1891 CicoHomeScreen::TerminateApp(const char*appid)
1892 {
1893     hs_instance->TerminateApp_i(appid);
1894 }
1895
1896 /*--------------------------------------------------------------------------*/
1897 /**
1898  * @brief   CicoHomeScreen::setActiveApp
1899  *          active(touch operate app) notice
1900  *
1901  * @param[in]   appid
1902  * @return      none
1903  */
1904 /*--------------------------------------------------------------------------*/
1905 void
1906 CicoHomeScreen::setActiveApp(const char* appid)
1907 {
1908     if ((NULL == appid) || (0 == appid) || (0 == strlen(appid))) {
1909         return;
1910     }
1911     if (NULL != m_appHis) {
1912         m_appHis->activeApp(appid);
1913     }
1914 }
1915
1916 /*--------------------------------------------------------------------------*/
1917 /**
1918  * @brief   CicoHomeScreen::SetNightMode
1919  *          set night mode theme
1920  *
1921  * @param[in]   data    user data
1922  */
1923 /*--------------------------------------------------------------------------*/
1924 void
1925 CicoHomeScreen::SetNightMode(void* data)
1926 {
1927     ICO_TRA("CicoHomeScreen::SetNightMode Enter");
1928    // night mode action
1929     hs_instance->ctl_bar_window->SetNightMode();
1930     hs_instance->menu_window->SetNightMode();
1931     ICO_TRA("CicoHomeScreen::SetNightMode Leave");
1932 }
1933
1934 /*--------------------------------------------------------------------------*/
1935 /**
1936  * @brief   CicoHomeScreen::SetRegulation
1937  *          regulation action and set regualtion theme
1938  *
1939  * @param[in]   data    user data
1940  */
1941 /*--------------------------------------------------------------------------*/
1942 void
1943 CicoHomeScreen::SetRegulation(void* data)
1944 {
1945     ICO_TRA("CicoHomeScreen::SetRegulation Enter");
1946     // window control
1947     hs_instance->controlRegulation();
1948     // regulation action
1949     hs_instance->ctl_bar_window->SetRegulation();
1950     ico_syc_animation_t animation;
1951     animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1952     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1953     hs_instance->menu_window->Hide(&animation);
1954
1955     // force focus change
1956     if (false == CicoHSSystemState::getInstance()->getRegulation()) {
1957         CicoHSAppInfo *active_appinfo = hs_instance->GetActiveAppInfo();
1958         if (NULL != active_appinfo) {
1959             ico_syc_change_active(active_appinfo->GetAppId(),
1960                                   active_appinfo->GetLastSurface());
1961             ico_syc_change_active(active_appinfo->GetAppId(), 0);
1962         }
1963     }
1964     else {
1965         if (NULL != hs_instance->ctl_bar_window) {
1966             const char *ctl_bar_appid = hs_instance->ctl_bar_window->GetAppId();
1967             int ctl_bar_surface = hs_instance->ctl_bar_window->GetSurfaceId();
1968             ico_syc_change_active(ctl_bar_appid, ctl_bar_surface);
1969             ico_syc_change_active(ctl_bar_appid, 0);
1970         }
1971     }
1972
1973     ICO_TRA("CicoHomeScreen::SetRegulation Leave");
1974 }
1975
1976 /*--------------------------------------------------------------------------*/
1977 /**
1978  * @brief   CicoHomeScreen::RenewAppInfoList_i
1979  *          renewal application info list
1980  *
1981  * @param[in]   none
1982  * @return      none
1983  */
1984 /*--------------------------------------------------------------------------*/
1985 void
1986 CicoHomeScreen::RenewAppInfoList_i(void)
1987 {
1988     int ii = 0;
1989     int kk = 0;
1990     CicoHSAppInfo *tmp_apps_info[ICO_HS_MAX_APP_NUM];
1991     int tmp_application_num = 0;
1992     const char *appid_p = 0;
1993
1994     for(ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++){
1995         tmp_apps_info[ii] = NULL;
1996     }
1997
1998     /* get APP information*/
1999     std::vector<CicoAilItems> aillist = life_cycle_controller->getAilList();
2000
2001     /*create instance*/
2002     for ( ii = 0;
2003          (ii < (int)aillist.size()) && (ii < ICO_HS_MAX_APP_NUM);
2004          ii++)  {
2005         ICO_DBG("aillist[%d].m_appid.c_str() = %s",
2006                  ii, aillist[ii].m_appid.c_str());
2007
2008         for (kk = 0; kk < ICO_HS_MAX_APP_NUM; kk++) {
2009             if (apps_info[kk] == NULL) {
2010                 continue;
2011             }
2012
2013             if (strcmp(aillist[ii].m_appid.c_str(),
2014                 apps_info[kk]->GetAppId()) == 0) {
2015
2016                 tmp_apps_info[ii] = apps_info[kk];
2017                 ICO_DBG("shift aillist[%d].m_appid.c_str() = %s",
2018                          ii, aillist[ii].m_appid.c_str());
2019                 break;
2020             }
2021         }
2022         if (kk == ICO_HS_MAX_APP_NUM) {
2023             tmp_apps_info[ii] = new CicoHSAppInfo(aillist[ii].m_appid.c_str());
2024             ICO_DBG("create aillist[%d].m_appid.c_str() = %s",
2025                      ii, aillist[ii].m_appid.c_str());
2026         }
2027         tmp_application_num++;
2028     }
2029
2030     /* delete instance */
2031     for (ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
2032         if (apps_info[ii] == NULL) {
2033             continue;
2034         }
2035         appid_p = apps_info[ii]->GetAppId();
2036         for ( kk = 0; kk < tmp_application_num; kk++) {
2037             if (strcmp(appid_p, tmp_apps_info[kk]->GetAppId()) == 0) {
2038                 break;
2039             }
2040         }
2041         if (kk == tmp_application_num) {
2042             delete apps_info[ii];
2043             ICO_DBG("delete apps_info[%d]->GetAppId() = %s",
2044                     ii, appid_p);
2045         }
2046     }
2047
2048     /* set apps info */
2049     for ( ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
2050         apps_info[ii] = tmp_apps_info[ii];
2051     }
2052
2053     application_num = tmp_application_num;
2054 }
2055
2056 /*--------------------------------------------------------------------------*/
2057 /**
2058  * @brief   CicoHomeScreen::RenewAppInfoList
2059  *          renewal appinfolist
2060  *
2061  * @param[in]   none
2062  * @return      none
2063  */
2064 /*--------------------------------------------------------------------------*/
2065 void
2066 CicoHomeScreen::RenewAppInfoList(void)
2067 {
2068     ICO_TRA("CicoHomeScreen::RenewAppInfoList Enter");
2069     hs_instance->RenewAppInfoList_i();
2070     ICO_TRA("CicoHomeScreen::RenewAppInfoList Leave");
2071 }
2072
2073 /*--------------------------------------------------------------------------*/
2074 /**
2075  * @brief   CicoHomeScreen::startupCheckAdd
2076  *          start-up application infomation add
2077  *
2078  * @param[in]  pid
2079  * @param[in]  appid
2080  * @return     none
2081  */
2082 /*--------------------------------------------------------------------------*/
2083 void CicoHomeScreen::startupCheckAdd(int pid, const std::string& appid,
2084                                      bool bSubDisp)
2085 {
2086     if (NULL != m_appHis) {
2087         m_appHis->startupCheckAdd(pid, appid, bSubDisp);
2088     }
2089 }
2090
2091 /*--------------------------------------------------------------------------*/
2092 /**
2093  * @brief   CicoHomeScreen::startupCheck
2094  *          start-up application check
2095  *
2096  * @param[in]  appid check target
2097  */
2098 /*--------------------------------------------------------------------------*/
2099 void CicoHomeScreen::startupCheck(const char* appid)
2100 {
2101     ICO_TRA("CicoHomeScreen::startupCheck Enter");
2102     if (NULL == life_cycle_controller) {
2103         ICO_ERR("life_cycle_controller is null");
2104         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2105         return;
2106     }
2107     if (NULL == m_appHis) {
2108         ICO_ERR("m_appHis is null");
2109         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2110         return;
2111     }
2112     if (false == m_appHis->isStartupChecking()) {
2113         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2114         return;
2115     }
2116     m_appHis->update_appid();
2117     m_appHis->startupEntryFinish(appid);
2118     if (false == m_appHis->isFinish()) {
2119         ICO_TRA("CicoHomeScreen::startupCheck Leave");
2120         return;
2121     }
2122     finishStartup();
2123     ICO_TRA("CicoHomeScreen::startupCheck Leave");
2124 }
2125
2126 /*--------------------------------------------------------------------------*/
2127 /**
2128  * @brief   CicoHomeScreen::finishStartup
2129  *          start-up application check
2130  *
2131  * @param[in]  appid check target
2132  */
2133 /*--------------------------------------------------------------------------*/
2134
2135 void CicoHomeScreen::finishStartup(void)
2136 {
2137     ICO_TRA("CicoHomeScreen::finishStartup Enter");
2138
2139     string last = m_appHis->getLastStartupAppid();
2140     const string& subDisp = m_appHis->getSubDispAppid();
2141
2142     list<string> h = m_appHis->getAppHistory();
2143     // last appid is empty then get new last appid
2144     if (true == last.empty()) {
2145         list<string>::iterator it_h = h.begin();
2146         while (it_h != h.end()) {
2147             if (0 != subDisp.compare(*it_h)) {
2148                 last = *it_h;
2149             }
2150             ++it_h;
2151         }
2152     }
2153
2154     list<string>::reverse_iterator rit_h = h.rbegin();
2155     while(rit_h != h.rend()) {
2156         CicoHSAppInfo *ai = GetAppInfo((*rit_h).c_str());
2157         if (ai == NULL) {
2158             ++rit_h;
2159             continue;
2160         }
2161         ICO_DBG("Raise %s", (*rit_h).c_str());
2162         {
2163             const char* appid = ai->GetAppId();
2164             int surface = ai->GetLastSurface();
2165             if ((0 != last.compare(appid)) && (0 != subDisp.compare(appid))) {
2166                 ico_syc_show(appid, surface, NULL);
2167                 ico_syc_hide(appid, surface, NULL);
2168             }
2169         }
2170         ++rit_h;
2171     }
2172
2173     CicoHSAppInfo *ai = GetAppInfo(subDisp.c_str());
2174     if (ai != NULL) {
2175         requestChangeZone(ai);
2176     }
2177
2178     ai = GetAppInfo(last.c_str());
2179     if (ai != NULL) {
2180         const char* appid = ai->GetAppId();
2181         int surface = ai->GetLastSurface();
2182         ico_syc_show(appid, surface, NULL);
2183         ico_syc_change_active(appid, surface);
2184         hs_instance->SetActiveAppInfo(appid);
2185     }
2186
2187     m_appHis->stopStartupCheck();
2188     ICO_TRA("CicoHomeScreen::finishStartup Leave");
2189 }
2190
2191 /*--------------------------------------------------------------------------*/
2192 /**
2193  * @brief   CicoHomeScreen::readStartupApp
2194  *          read start-up application data
2195  *
2196  * @param[in]  appid check target
2197  */
2198 /*--------------------------------------------------------------------------*/
2199 void CicoHomeScreen::readStartupApp(std::vector<pairAppidSubd>& apps)
2200 {
2201     ICO_TRA("CicoHomeScreen::readStartupApp Enter");
2202     if (NULL == m_appHis) {
2203         apps.clear();
2204     }
2205     else {
2206         m_appHis->readAppHistory(apps);
2207     }
2208     ICO_TRA("CicoHomeScreen::readStartupApp Leave(%d)", (int)apps.size());
2209     return;
2210 }
2211
2212 /*--------------------------------------------------------------------------*/
2213 /**
2214  * @brief   CicoHomeScreen::requestHideAppid
2215  *          request Hide appid
2216  *
2217  * @param  app appid
2218  */
2219 /*--------------------------------------------------------------------------*/
2220 void CicoHomeScreen::requestHideAppid(const std::string& app)
2221 {
2222     const char* appid = app.c_str();
2223     ICO_TRA("start %s", appid);
2224     CicoHSAppInfo *ai = GetAppInfo(appid);
2225     if (NULL == ai) {
2226         ICO_DBG("end %d", appid);
2227         return;
2228     }
2229     int surface = ai->GetLastSurface();
2230     ico_syc_hide(appid, surface, NULL);
2231     ICO_TRA("end");
2232 }
2233
2234 /*--------------------------------------------------------------------------*/
2235 /**
2236  * @brief   CicoHomeScreen::requestShowAppid
2237  *          request Show appid
2238  *
2239  * @param  app appid
2240  */
2241 /*--------------------------------------------------------------------------*/
2242 void CicoHomeScreen::requestShowAppid(const std::string& app)
2243 {
2244     const char* appid = app.c_str();
2245     ICO_TRA("start %s", appid);
2246     CicoHSAppInfo *ai = GetAppInfo(appid);
2247     if (NULL == ai) {
2248         ICO_DBG("end %d", appid);
2249         return;
2250     }
2251     int surface = ai->GetLastSurface();
2252     ico_syc_show(appid, surface, NULL);
2253     ICO_TRA("end");
2254 }
2255
2256 /*--------------------------------------------------------------------------*/
2257 /**
2258  * @brief   CicoHomeScreen::requestActivationAppid
2259  *          request Activation
2260  *
2261  * @param  app appid
2262  */
2263 /*--------------------------------------------------------------------------*/
2264 void CicoHomeScreen::requestActivationAppid(const std::string& app)
2265 {
2266     const char* appid = app.c_str();
2267     ICO_TRA("CicoHomeScreen::requestActivationAppid Enter(%s)", appid);
2268     CicoHSAppInfo *ai = GetAppInfo(appid);
2269     if (NULL == ai) {
2270         ICO_DBG("end %d", appid);
2271         return;
2272     }
2273     int surface = ai->GetLastSurface();
2274     hs_instance->SetActiveAppInfo(app.c_str());
2275     ico_syc_show(appid, surface, NULL);
2276     ico_syc_change_active(appid, surface);
2277     ICO_TRA("CicoHomeScreen::requestActivationAppid Leave");
2278 }
2279
2280 /*--------------------------------------------------------------------------*/
2281 /**
2282  * @brief   CicoHomeScreen::controlRegulation
2283  *          controlRegulation
2284  *
2285  * @param  reqStt true / false
2286  */
2287 /*--------------------------------------------------------------------------*/
2288 void CicoHomeScreen::controlRegulation(bool regStt)
2289 {
2290     ICO_TRA("CicoHomeScreen::controlRegulation Enter(%s)",
2291             regStt? "true": "false");
2292     if (NULL == m_appHis) {
2293         ICO_ERR("m_appHis is null");
2294         ICO_TRA("CicoHomeScreen::controlRegulation Leave");
2295         return;
2296     }
2297     const string& wapp = m_appHis->getSelectApp(); // select appid get
2298     if (false == wapp.empty()) { // select appid nothing
2299         const string& napp = m_appHis->getNearHistory(); // history top appid get
2300         if (0 != wapp.compare(napp)) { // history top, wait app is Eqale
2301             requestHideAppid(napp);
2302             requestActivationAppid(wapp);
2303             m_appHis->moveHistoryHead(wapp);
2304         }
2305         m_appHis->clearSelectApp(); // select appid clear
2306         m_appHis->homeSwipe();
2307     }
2308     ICO_TRA("CicoHomeScreen::controlRegulation Leave");
2309 }
2310
2311 /*--------------------------------------------------------------------------*/
2312 /**
2313  * @brief   CicoHomeScreen::ActivationUpdate
2314  *          history update by swipe app
2315  *
2316  * @return bool
2317  * @retval true history update
2318  * @retval false no history updath
2319  */
2320 /*--------------------------------------------------------------------------*/
2321 bool
2322 CicoHomeScreen::ActivationUpdate(void)
2323 {
2324     return hs_instance->ActivationUpdate_i();
2325 }
2326
2327 /*--------------------------------------------------------------------------*/
2328 /**
2329  * @brief   CicoHomeScreen::ActivationUpdate_i
2330  *          history update by swipe app
2331  *
2332  * @return bool
2333  * @retval true history update
2334  * @retval false no history updath
2335  */
2336 /*--------------------------------------------------------------------------*/
2337 bool
2338 CicoHomeScreen::ActivationUpdate_i(void)
2339 {
2340     ICO_TRA("CicoHomeScreen::ActivationUpdate_i Enter");
2341     if (NULL == m_appHis) {
2342         ICO_ERR("m_appHis is null");
2343         ICO_TRA("CicoHomeScreen::ActivationUpdate_i Leave(false)");
2344         return false;
2345     }
2346     bool bR = false;
2347     const string& wapp = m_appHis->getSelectApp(); // select appid get
2348     if (false == wapp.empty()) { // select appid nothing
2349         const string& napp = m_appHis->getNearHistory(); // history top appid get
2350         if (0 != wapp.compare(napp)) { // history top, wait app is Eqale
2351             requestActivationAppid(wapp);
2352             m_appHis->moveHistoryHead(wapp);
2353             bR = true;
2354         }
2355         m_appHis->clearSelectApp(); // select appid clear
2356         m_appHis->homeSwipe();
2357     }
2358     ICO_TRA("CicoHomeScreen::ActivationUpdate_i Leave(%s)",
2359             bR? "true": "false");
2360     return bR;
2361 }
2362
2363 /*--------------------------------------------------------------------------*/
2364 /**
2365  * @brief   CicoHomeScreen::ShowApp_i
2366  *          show app
2367  *
2368  * @param  app appid
2369  */
2370 /*--------------------------------------------------------------------------*/
2371 void
2372 CicoHomeScreen::ShowApp_i(const std::string& app)
2373 {
2374     CicoHSAppInfo *appinfo = GetAppInfo(app.c_str());
2375     if (appinfo == NULL)    {
2376         ICO_TRA("end get appinfo is NULL");
2377         return;
2378     }
2379
2380     ico_syc_animation_t animation;
2381     animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_FADE;
2382     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
2383
2384     ico_syc_show(appinfo->GetAppId(), appinfo->GetLastSurface(), &animation);
2385     ico_syc_change_active(appinfo->GetAppId(), appinfo->GetLastSurface());
2386     hs_instance->SetActiveAppInfo(appinfo->GetAppId());
2387     //raise
2388 //    RaiseApplicationWindow(appinfo->GetAppId(),
2389 //                           appinfo->GetLastSurface());
2390     ICO_DBG("raise app %s", app.c_str());
2391     m_appHis->moveHistoryHead(app);
2392 }
2393
2394 /*--------------------------------------------------------------------------*/
2395 /**
2396  * @brief   CicoHomeScreen::ShowApp
2397  *          show app
2398  *
2399  * @param  app appid
2400  */
2401 /*--------------------------------------------------------------------------*/
2402 void
2403 CicoHomeScreen::ShowApp(const std::string& app)
2404 {
2405     hs_instance->ShowApp_i(app);
2406 }
2407
2408 /*--------------------------------------------------------------------------*/
2409 /**
2410  * @brief   CicoHomeScreen::HideAppid
2411  *          hide app
2412  *
2413  * @param  app appid
2414  */
2415 /*--------------------------------------------------------------------------*/
2416 void
2417 CicoHomeScreen::HideApp(const std::string& app)
2418 {
2419     const char* appid = app.c_str();
2420     ICO_TRA("start %s", appid);
2421     CicoHSAppInfo *ai = GetAppInfo(appid);
2422     if (NULL == ai) {
2423         ICO_DBG("end %d", appid);
2424         return;
2425     }
2426
2427     ico_syc_animation_t animation;
2428     animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_FADE;
2429     animation.time = ICO_HS_MENU_ANIMATION_DURATION;
2430
2431     int surface = ai->GetLastSurface();
2432     ico_syc_hide(appid, surface, &animation);
2433     ICO_TRA("end");
2434 }
2435
2436 /*--------------------------------------------------------------------------*/
2437 /**
2438  * @brief   CicoHomeScreen::MoveApp
2439  *          move app
2440  *
2441  * @param  app appid
2442  * @param  zone zone
2443  */
2444 /*--------------------------------------------------------------------------*/
2445 void
2446 CicoHomeScreen::MoveApp(const std::string& app, const std::string& zone)
2447 {
2448     CicoHSAppInfo *appinfo = GetAppInfo((const char*)app.c_str());
2449     if ((CicoHSAppInfo*)0 == appinfo) {
2450         ICO_DBG("GetAppInfo(%s) is NULL" , app.c_str());
2451         return;
2452     }
2453
2454     int surface = appinfo->GetLastSurface();
2455     ico_hs_window_info* wininfo = appinfo->GetWindowInfobySurface(surface);
2456     int layer = HS_LAYER_APPLICATION;
2457     const char *dispzone = (const char*)zone.c_str();
2458     ico_syc_win_move_t move = {
2459         .zone   = (char*)dispzone,
2460         .layer  = layer,
2461         .pos_x  = 0,
2462         .pos_y  = 0,
2463         .width  = 0,
2464         .height = 0
2465     };
2466
2467     ico_syc_move(wininfo->appid, wininfo->surface, &move,
2468                  &hs_instance->moveZoneAnimation);
2469 }
2470 // vim: set expandtab ts=4 sw=4: