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 "CicoHomeScreen.h"
  15 #include "CicoHSSystemState.h"
  16
  17 /*============================================================================*/
  18 /* static members                                                             */
  19 /*============================================================================*/
  20 CicoHomeScreen * CicoHomeScreen::hs_instance;
  21
  22 /*============================================================================*/
  23 /* functions                                                                  */
  24 /*============================================================================*/
  25 /*--------------------------------------------------------------------------*/
  26 /**
  27  * @brief   CicoHomeScreen::CicoHomeScreen
  28  *          Constractor
  29  *
  30  * @param[in]   none
  31  * @return      none
  32  */
  33 /*--------------------------------------------------------------------------*/
  34 CicoHomeScreen::CicoHomeScreen(void)
  35 {
  36     application_num = 0;
  37     for(int ii = 0;ii < ICO_HS_MAX_APP_NUM;ii++){
  38         apps_info[ii] = NULL;
  39     }
  40
  41     hs_app_info = NULL;
  42     sb_app_info = NULL;
  43     os_app_info = NULL;
  44
  45     full_width = 1;
  46     full_height = 1;
  47     menu_width = 1;
  48     menu_height = 1;
  49     bg_width = 1;
  50     bg_height = 1;
  51     ctl_bar_width = 1;
  52     ctl_bar_height = 1;
  53
  54     menu_window = NULL;
  55     back_window = NULL;
  56     ctl_bar_window = NULL;
  57
  58     //mode = ICO_HS_MODE_MENU;
  59     mode = ICO_HS_MODE_APPLICATION;
  60     config = NULL;
  61     hs_instance = NULL;
  62
  63 }
  64
  65 /*--------------------------------------------------------------------------*/
  66 /**
  67  * @brief   CicoHomeScreen::~CicoHomeScreen
  68  *          Destractor
  69  *
  70  * @param[in]   none
  71  * @return      none
  72  */
  73 /*--------------------------------------------------------------------------*/
  74 CicoHomeScreen::~CicoHomeScreen(void)
  75 {
  76     /* Do not somthing to do */
  77 }
  78
  79 /*--------------------------------------------------------------------------*/
  80 /**
  81  * @brief   CicoHomeScreen::ShowHomeScreenLayer
  82  *          Show Home screen layer
  83  *
  84  * @param[in]   none
  85  * @return      none
  86  */
  87 /*--------------------------------------------------------------------------*/
  88 void
  89 CicoHomeScreen::ShowHomeScreenLayer(void)
  90 {
  91     /*show home screen layers*/
  92     ico_syc_show_layer(HS_LAYER_APPLICATION);
  93     ico_syc_show_layer(HS_LAYER_HOMESCREEN);
  94     ico_syc_show_layer(HS_LAYER_TOUCH);
  95 }
  96
  97 /*--------------------------------------------------------------------------*/
  98 /**
  99  * @brief   CicoHomeScreen::GetHsPackageName
 100  *          get HomeScreen package name
 101  *
 102  * @param[in]   none
 103  * @return      package name
 104  */
 105 /*--------------------------------------------------------------------------*/
 106 char *
 107 CicoHomeScreen::GetHsPackageName(void)
 108 {
 109     return hs_package_name;
 110 }
 111
 112 /*--------------------------------------------------------------------------*/
 113 /**
 114  * @brief   CicoHomeScreen::GetHsPackageName
 115  *          get StatusBar package name
 116  *
 117  * @param[in]   none
 118  * @return      package name
 119  */
 120 /*--------------------------------------------------------------------------*/
 121 char *
 122 CicoHomeScreen::GetSbPackageName(void)
 123 {
 124     return sb_package_name;
 125 }
 126
 127 /*--------------------------------------------------------------------------*/
 128 /**
 129  * @brief   CicoHomeScreen::GetHsPackageName
 130  *          get OnScreen package name
 131  *
 132  * @param[in]   none
 133  * @return      package name
 134  */
 135 /*--------------------------------------------------------------------------*/
 136 char *
 137 CicoHomeScreen::GetOsPackageName(void)
 138 {
 139     return os_package_name;
 140 }
 141
 142 /*--------------------------------------------------------------------------*/
 143 /**
 144  * @brief   CicoHomeScreen::CreateAppInfoList
 145  *          create application info list
 146  *
 147  * @param[in]   none
 148  * @return      none
 149  */
 150 /*--------------------------------------------------------------------------*/
 151 void
 152 CicoHomeScreen::CreateAppInfoList(void)
 153 {
 154     /* get APP information*/
 155     std::vector<CicoSCAilItems> aillist = life_cycle_controller->getAilList();
 156
 157     for(int ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
 158         if(apps_info[ii] != NULL){
 159             delete apps_info[ii];
 160         }
 161     }
 162
 163     /*create instance*/
 164     application_num = 0;
 165     for(unsigned int ii = 0;
 166         (ii < aillist.size()) && (ii < ICO_HS_MAX_APP_NUM);
 167         ii++) {
 168         apps_info[ii] = new CicoHSAppInfo(aillist[ii].m_appid.c_str());
 169         application_num++;
 170     }
 171 }
 172
 173 /*--------------------------------------------------------------------------*/
 174 /**
 175  * @brief   CicoHomeScreen::GetAppInfo
 176  *          get application info
 177  *
 178  * @param[in]   appid    application id
 179  * @return      Application info
 180  */
 181 /*--------------------------------------------------------------------------*/
 182 CicoHSAppInfo *
 183 CicoHomeScreen::GetAppInfo(const char *appid)
 184 {
 185     for(int ii = 0;ii < application_num;ii++){
 186         if(strcmp(apps_info[ii]->GetAppId(),appid) == 0){
 187             return apps_info[ii];
 188         }
 189     }
 190     return NULL;
 191 }
 192
 193 /*--------------------------------------------------------------------------*/
 194 /**
 195  * @brief   CicoHomeScreen::GetAppStatus
 196  *          get application status
 197  *
 198  * @param[in]   appid    application id
 199  * @return      Application info
 200  */
 201 /*--------------------------------------------------------------------------*/
 202 bool
 203 CicoHomeScreen::GetAppStatus(const char *appid)
 204 {
 205     for(int ii = 0;ii < hs_instance->application_num;ii++){
 206         if(strcmp(hs_instance->apps_info[ii]->GetAppId(),appid) == 0){
 207             return hs_instance->apps_info[ii]->GetStatus();
 208         }
 209     }
 210     return false;
 211 }
 212
 213 /*--------------------------------------------------------------------------*/
 214 /**
 215  * @brief   CicoHomeScreen::GetWindowInfo
 216  *          get window info
 217  *
 218  * @param[in]   appinfo    application info
 219  * @param[in]   window    window name
 220  * @return      Window info
 221  */
 222 /*--------------------------------------------------------------------------*/
 223 ico_hs_window_info *
 224 CicoHomeScreen::GetWindowInfo(CicoHSAppInfo *appinfo,const char *window)
 225 {
 226     return appinfo->GetWindowInfo(window);
 227 }
 228
 229 /*--------------------------------------------------------------------------*/
 230 /**
 231  * @brief   CicoHomeScreen::UpdateTile
 232  *          update tile image
 233  *
 234  * @param[in]   appid    application id
 235  * @return      Window info
 236  */
 237 /*--------------------------------------------------------------------------*/
 238 void
 239 CicoHomeScreen::UpdateTile(const char *appid)
 240 {
 241     CicoHSAppInfo *appinfo = GetAppInfo(appid);
 242     if(appinfo == NULL){
 243         return;
 244     }
 245     if(appinfo->GetStatus() == false){
 246         //show icon
 247         menu_window->ValidMenuIcon(appid);
 248         ICO_DBG("CicoHomeScreen::UpdateTile: show menuIcon %s",appid);
 249     }else{
 250         //show thumbnail
 251         menu_window->ValidThumbnail(appid,appinfo->GetLastSurface());
 252         ICO_DBG("CicoHomeScreen::ExecuteApp_i: raise app %s",appid);
 253     }
 254 }
 255
 256 /*--------------------------------------------------------------------------*/
 257 /**
 258  * @brief   CicoHomeScreen::ExecuteApp_i
 259  *          execute and showing application
 260  *
 261  * @param[in]   appid    application id
 262  * @return      none
 263  */
 264 /*--------------------------------------------------------------------------*/
 265 void
 266 CicoHomeScreen::ExecuteApp_i(const char *appid)
 267 {
 268     CicoHSAppInfo *appinfo = GetAppInfo(appid);
 269     if(appinfo == NULL){
 270         return;
 271     }
 272
 273     if(appinfo->GetStatus() == false){
 274         //execute
 275         appinfo->Execute();
 276         ICO_DBG("CicoHomeScreen::ExecuteApp_i: execute app %s",appid);
 277     }else{
 278         //raise
 279         RaiseApplicationWindow(appinfo->GetAppId(),appinfo->GetLastSurface());
 280         ICO_DBG("CicoHomeScreen::ExecuteApp_i: raise app %s",appid);
 281     }
 282     /* hide HomeScreen layer                        */
 283     if(GetMode() == ICO_HS_MODE_MENU){
 284         ChangeMode(ICO_HS_SHOW_HIDE_PATTERN_FADE);
 285     }
 286 }
 287
 288 /*--------------------------------------------------------------------------*/
 289 /**
 290  * @brief   CicoHomeScreen::TerminateApp_i
 291  *          teminate application
 292  *
 293  * @param[in]   appid    application id
 294  * @return      none
 295  */
 296 /*--------------------------------------------------------------------------*/
 297 void
 298 CicoHomeScreen::TerminateApp_i(const char *appid)
 299 {
 300     if(appid != NULL){
 301         CicoHSAppInfo *appinfo = GetAppInfo(appid);
 302         if(appinfo == NULL){
 303             return;
 304         }
 305
 306         //terminate
 307         appinfo->Terminate();
 308     }
 309     /* hide HomeScreen layer                        */
 310     if(GetMode() == ICO_HS_MODE_MENU){
 311         ChangeMode(ICO_HS_SHOW_HIDE_PATTERN_FADE);
 312     }
 313 }
 314
 315 /*--------------------------------------------------------------------------*/
 316 /**
 317  * @brief   CicoHomeScreen::ShowHomeScreenWindow
 318  *          show window (home screen)
 319  *
 320  * @param[in]   win attr    window attribute
 321  * @return      none
 322  */
 323 /*--------------------------------------------------------------------------*/
 324 void
 325 CicoHomeScreen::ShowHomeScreenWindow(ico_syc_win_attr_t *win_attr)
 326 {
 327     ico_syc_win_move_t move;
 328     int layer;
 329     move.zone = NULL;
 330     move.pos_x = 0;
 331     move.width = full_width;
 332
 333     if(strncmp(win_attr->name,ICO_HS_BACK_WINDOW_TITLE,
 334                ICO_MAX_TITLE_NAME_LEN) == 0){
 335         move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
 336         move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
 337                       ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 338         layer = HS_LAYER_BACKGROUND;
 339     }else if(strncmp(win_attr->name,ICO_HS_CONTROL_BAR_WINDOW_TITLE,
 340              ICO_MAX_TITLE_NAME_LEN) == 0){
 341         move.pos_y = full_height - ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 342         move.height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 343         layer = HS_LAYER_TOUCH;
 344     }else if(strncmp(win_attr->name,ICO_HS_MENU_WINDOW_TITLE,
 345              ICO_MAX_TITLE_NAME_LEN) == 0){
 346         move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
 347         move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
 348                       ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 349         layer = HS_LAYER_HOMESCREEN;
 350     }else{
 351         /*do nothing*/
 352         return;
 353     }
 354
 355     ico_syc_change_layer(win_attr->appid,win_attr->surface,layer);
 356     ICO_DBG("CicoHomeScreen::ShowHomeScreenWindow: id(%s) name(%s) surface(%d) pos(%d,%d) size(%d,%d)",win_attr->appid,
 357             win_attr->name,win_attr->surface,move.pos_x,move.pos_y,
 358             move.width,move.height);
 359     ico_syc_move(win_attr->appid,win_attr->surface,&move,NULL);
 360
 361     /*first time menu is unvisible*/
 362     if((strncmp(win_attr->name,ICO_HS_MENU_WINDOW_TITLE,
 363              ICO_MAX_TITLE_NAME_LEN) == 0) &&
 364        (GetMode() == ICO_HS_MODE_APPLICATION)){
 365         return;
 366     }
 367
 368     ico_syc_show(win_attr->appid, win_attr->surface,NULL);
 369 }
 370
 371 /*--------------------------------------------------------------------------*/
 372 /**
 373  * @brief   CicoHomeScreen::ShowStatusBarWindow
 374  *          show window (home screen)
 375  *
 376  * @param[in]   win attr    window attribute
 377  * @return      none
 378  */
 379 /*--------------------------------------------------------------------------*/
 380 void
 381 CicoHomeScreen::ShowStatusBarWindow(ico_syc_win_attr_t *win_attr)
 382 {
 383     ico_syc_win_move_t move;
 384     int layer;
 385     move.zone = NULL;
 386     move.pos_x = 0;
 387     move.pos_y = 0;
 388     move.width = full_width;
 389     move.height = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
 390     layer = HS_LAYER_HOMESCREEN;
 391
 392     ico_syc_change_layer(win_attr->appid,win_attr->surface,layer);
 393     ICO_DBG("CicoHomeScreen::ShowStatusBarWindow: id(%s) name(%s) surface(%d) pos(%d,%d) size(%d,%d)",win_attr->appid,
 394             win_attr->name,win_attr->surface,move.pos_x,move.pos_y,
 395             move.width,move.height);
 396     ico_syc_move(win_attr->appid,win_attr->surface,&move,NULL);
 397     ico_syc_show(win_attr->appid, win_attr->surface,NULL);
 398 }
 399 /*--------------------------------------------------------------------------*/
 400 /**
 401  * @brief   CicoHomeScreen::ShowApplicationWindow
 402  *          show window (application)
 403  *
 404  * @param[in]   win attr    window attribute
 405  * @return      none
 406  */
 407 /*--------------------------------------------------------------------------*/
 408 void
 409 CicoHomeScreen::ShowApplicationWindow(ico_syc_win_attr_t *win_attr)
 410 {
 411
 412     ico_syc_win_move_t move;
 413     int layer;
 414     move.zone = 0;
 415     move.pos_x = 0;
 416     move.width = full_width;
 417     move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
 418     move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
 419                   ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 420     layer = HS_LAYER_APPLICATION;
 421
 422     ico_syc_change_layer(win_attr->appid,win_attr->surface,layer);
 423     ico_syc_move(win_attr->appid,win_attr->surface,&move,NULL);
 424     ico_syc_show(win_attr->appid, win_attr->surface,NULL);
 425 }
 426 /*--------------------------------------------------------------------------*/
 427 /**
 428  * @brief   CicoHomeScreen::RaiseApplicationWindow
 429  *          raise window (application)
 430  *
 431  * @param[in]   appid      application id
 432  * @param[in]   surface    surface
 433  * @return      none
 434  */
 435 /*--------------------------------------------------------------------------*/
 436 void
 437 CicoHomeScreen::RaiseApplicationWindow(const char *appid,int surface)
 438 {
 439     ico_syc_show(appid, surface,NULL);
 440 }
 441 /*--------------------------------------------------------------------------*/
 442 /**
 443  * @brief   CicoHomeScreen::EventCallBack
 444  *          callback for system controller
 445  *
 446  * @param[in]   event      kind of event
 447  * @param[in]   detail     detail
 448  * @param[in]   user_data  user data
 449  * @return      none
 450  */
 451 /*--------------------------------------------------------------------------*/
 452 void
 453 CicoHomeScreen::EventCallBack(const ico_syc_ev_e event,
 454                               const void *detail,void *user_data)
 455 {
 456     ICO_DBG("CicoHomeScreen::EventCallBack: start (event %d)",event);
 457     if(event == ICO_SYC_EV_WIN_CREATE){
 458         ico_syc_win_info_t *win_info =
 459             reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
 460         ICO_DBG("CicoHomeScreen::EventCallBack : win create %s %i",
 461                 win_info->appid,win_info->surface);
 462         /*only save information*/
 463         if(strncmp(win_info->appid, hs_instance->GetHsPackageName(),
 464                    ICO_HS_MAX_PROCESS_NAME) == 0){
 465            /*Home Screen*/
 466            hs_instance->hs_app_info->AddWindowInfo(win_info);
 467         }else if(strncmp(win_info->appid,
 468                          hs_instance->GetSbPackageName(),
 469                          ICO_HS_MAX_PROCESS_NAME) == 0){
 470             /*Status Bar*/
 471             hs_instance->sb_app_info->AddWindowInfo(win_info);
 472         }else if(strncmp(win_info->appid,
 473                          hs_instance->GetOsPackageName(),
 474                          ICO_HS_MAX_PROCESS_NAME) == 0){
 475             /*On Screen*/
 476             hs_instance->os_app_info->AddWindowInfo(win_info);
 477         }else{
 478             /*Application*/
 479             CicoHSAppInfo *appinfo =
 480                        hs_instance->GetAppInfo(win_info->appid);
 481             if(appinfo == NULL){
 482                 return;
 483             }
 484             appinfo->AddWindowInfo(win_info);
 485         }
 486     }
 487     else if(event == ICO_SYC_EV_WIN_DESTROY){
 488         ico_syc_win_info_t *win_info =
 489             reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
 490         ICO_DBG("CicoHomeScreen::EventCallBack : win delete %s %i",
 491                 win_info->appid,win_info->surface);
 492         /*only save information*/
 493         if(strncmp(win_info->appid, hs_instance->GetHsPackageName(),
 494                    ICO_HS_MAX_PROCESS_NAME) == 0){
 495             hs_instance->hs_app_info->FreeWindowInfo(win_info->name);
 496         }else if(strncmp(win_info->appid,
 497                          hs_instance->GetSbPackageName(),
 498                          ICO_HS_MAX_PROCESS_NAME) == 0){
 499             hs_instance->sb_app_info->FreeWindowInfo(win_info->name);
 500         }else if(strncmp(win_info->appid,
 501                          hs_instance->GetOsPackageName(),
 502                          ICO_HS_MAX_PROCESS_NAME) == 0){
 503             hs_instance->os_app_info->FreeWindowInfo(win_info->name);
 504         }else{
 505             /*Application*/
 506             CicoHSAppInfo *appinfo =
 507                        hs_instance->GetAppInfo(win_info->appid);
 508             if(appinfo == NULL){
 509                 return;
 510             }
 511             hs_instance->UpdateTile(win_info->appid);
 512             appinfo->FreeWindowInfo(win_info->name);
 513         }
 514     }
 515     else if(event == ICO_SYC_EV_WIN_ACTIVE){
 516         ico_syc_win_info_t *win_info =
 517             reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
 518         /*if application*/
 519         CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(win_info->appid);
 520         if(appinfo == NULL){
 521             return;
 522         }
 523         appinfo->SetLastSurface(win_info->surface);
 524     }
 525     else if(event == ICO_SYC_EV_WIN_ATTR_CHANGE){
 526         ico_syc_win_attr_t *win_attr =
 527             reinterpret_cast<ico_syc_win_attr_t*>(const_cast<void*>(detail));
 528         ICO_DBG("CicoHomeScreen::EventCallBack : win attr %s %s %d",
 529                 win_attr->appid,win_attr->name,win_attr->surface);
 530         if(strncmp(win_attr->appid, hs_instance->GetHsPackageName(),
 531                    ICO_HS_MAX_PROCESS_NAME) == 0){
 532             /*Home Screen*/
 533             hs_instance->hs_app_info->AddWindowAttr(win_attr);
 534             /*when Menu window*/
 535             if(strncmp(win_attr->name,ICO_HS_MENU_WINDOW_TITLE,
 536                        ICO_MAX_TITLE_NAME_LEN) == 0){
 537                 hs_instance->menu_window->SetMenuWindowID(win_attr->appid,
 538                     win_attr->surface);
 539             }
 540             else if(strncmp(win_attr->name,ICO_HS_CONTROL_BAR_WINDOW_TITLE,
 541                             ICO_MAX_TITLE_NAME_LEN) == 0){
 542                 hs_instance->ctl_bar_window->SetWindowID(win_attr->appid,
 543                                                          win_attr->surface);
 544             }
 545             ico_hs_window_info * l_win_info =
 546                      hs_instance->GetWindowInfo(hs_instance->hs_app_info,
 547                                                 win_attr->name);
 548             if(l_win_info == NULL){
 549                 return;
 550             }
 551             if(hs_instance->hs_app_info->GetShowed(l_win_info) == true){
 552                 return;
 553             }
 554             /*show window*/
 555             hs_instance->ShowHomeScreenWindow(win_attr);
 556             hs_instance->hs_app_info->SetShowed(l_win_info,true);
 557         }else if(strncmp(win_attr->appid, hs_instance->GetSbPackageName(),
 558                          ICO_HS_MAX_PROCESS_NAME) == 0){
 559             /*Status Bar*/
 560             hs_instance->sb_app_info->AddWindowAttr(win_attr);
 561             ico_hs_window_info * l_win_info =
 562                      hs_instance->GetWindowInfo(hs_instance->sb_app_info,
 563                                                 win_attr->name);
 564             if(l_win_info == NULL){
 565                 return;
 566             }
 567             if(hs_instance->sb_app_info->GetShowed(l_win_info) == true){
 568                 return;
 569             }
 570             hs_instance->ShowStatusBarWindow(win_attr);
 571             hs_instance->sb_app_info->SetShowed(l_win_info,true);
 572         }else if(strncmp(win_attr->appid, hs_instance->GetOsPackageName(),
 573                          ICO_HS_MAX_PROCESS_NAME) == 0){
 574             /*On Screen*/
 575             hs_instance->os_app_info->AddWindowAttr(win_attr);
 576         }else{
 577             ICO_DBG("CicoHomeScreen::EventCallBack : application window %s %s",
 578                 win_attr->appid,win_attr->name);
 579             /*Application*/
 580             CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(win_attr->appid);
 581             if(appinfo == NULL){
 582                 return;
 583             }
 584             ico_hs_window_info * l_win_info =
 585                       hs_instance->GetWindowInfo(appinfo,
 586                                                 win_attr->name);
 587             if(l_win_info == NULL){
 588                 return;
 589             }
 590             if(appinfo->GetShowed(l_win_info) == true){
 591                 return;
 592             }
 593
 594             appinfo->AddWindowAttr(win_attr);
 595             appinfo->SetLastSurface(win_attr->surface);
 596             hs_instance->ShowApplicationWindow(win_attr);
 597             ico_syc_change_active(win_attr->appid,win_attr->surface);
 598             hs_instance->UpdateTile(win_attr->appid);
 599             hs_instance->hs_app_info->SetShowed(l_win_info,true);
 600         }
 601     }
 602     else if(event == ICO_SYC_EV_THUMB_CHANGE){
 603         ico_syc_thumb_info_t *thumb_info =
 604             reinterpret_cast<ico_syc_thumb_info_t*>(const_cast<void*>(detail));
 605         CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(thumb_info->appid);
 606         ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_CHANGE %s",
 607                 thumb_info->appid);
 608         if(appinfo == NULL){
 609             return;
 610         }
 611         //show icon
 612         hs_instance->menu_window->SetThumbnail(thumb_info->appid,thumb_info->surface);
 613     }
 614     else if(event == ICO_SYC_EV_LAYER_ATTR_CHANGE){
 615
 616     }
 617     else if(event == ICO_SYC_EV_USERLIST){
 618
 619     }
 620     else if(event == ICO_SYC_EV_AUTH_FAIL){
 621
 622     }
 623     else if(event == ICO_SYC_EV_RES_ACQUIRE){
 624
 625     }
 626     else if(event == ICO_SYC_EV_RES_DEPRIVE){
 627
 628     }
 629     else if(event == ICO_SYC_EV_RES_WAITING){
 630
 631     }
 632     else if(event == ICO_SYC_EV_RES_REVERT){
 633
 634     }
 635     else if(event == ICO_SYC_EV_RES_RELEASE){
 636
 637     }
 638     else if(event == ICO_SYC_EV_INPUT_SET){
 639
 640     }
 641     else if(event == ICO_SYC_EV_INPUT_UNSET){
 642
 643     }
 644     else if(event == ICO_SYC_EV_STATE_CHANGE) {
 645         ico_syc_state_info_t *state_info =
 646             reinterpret_cast<ico_syc_state_info_t*>(const_cast<void*>(detail));
 647
 648         ICO_DBG("RECV: ICO_SYC_EV_STATE_CHANGE(id=%d state=%d)",
 649                 state_info->id, state_info->state);
 650         if (ICO_SYC_STATE_REGULATION == state_info->id) {
 651             // set regulation state
 652             CicoHSSystemState::getInstance()->setRegulation(
 653                 (state_info->state == ICO_SYC_STATE_ON) ? true : false);
 654             // regulation action
 655             ico_syc_animation_t animation;
 656             animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
 657             animation.time = ICO_HS_MENU_ANIMATION_DURATION;
 658             hs_instance->menu_window->Hide(&animation);
 659             hs_instance->ctl_bar_window->SetRegulation();
 660         }
 661         else if (ICO_SYC_STATE_NIGHTMODE == state_info->id) {
 662             // set night mode state
 663             CicoHSSystemState::getInstance()->setNightMode(
 664                 (state_info->state == ICO_SYC_STATE_ON) ? true : false);
 665             // night mode action
 666             hs_instance->ctl_bar_window->SetNightMode();
 667             hs_instance->menu_window->SetNightMode();
 668         }
 669     }
 670
 671     ICO_DBG("CicoHomeScreen::EventCallBack: end");
 672 }
 673
 674 /*--------------------------------------------------------------------------*/
 675 /**
 676  * @brief   CicoHomeScreen::StartRelations
 677  *          Execute Onscreen and Statusbar
 678  *
 679  * @param[in]   none
 680  * @return      OK
 681  */
 682 /*--------------------------------------------------------------------------*/
 683 int
 684 CicoHomeScreen::StartRelations(void)
 685 {
 686     int ret;
 687     strncpy(sb_package_name,
 688             (char *)config->ConfigGetString(ICO_HS_CONFIG_HOMESCREEN,
 689                                              ICO_HS_CONFIG_SB,
 690                                              ICO_HS_APPID_DEFAULT_SB),
 691             ICO_HS_MAX_PROCESS_NAME);
 692     strncpy(os_package_name,
 693              (char *)config->ConfigGetString(ICO_HS_CONFIG_HOMESCREEN,
 694                                              ICO_HS_CONFIG_ONS,
 695                                              ICO_HS_APPID_DEFAULT_ONS),
 696             ICO_HS_MAX_PROCESS_NAME);
 697
 698     /* start onscreen & statusbar apps */
 699 #if 0
 700     os_app_info = new CicoHSAppInfo(os_package_name);
 701     ret = os_app_info->Execute();
 702     if (ret < 0) {
 703         ICO_WRN("execute failed(%s) err=%d", os_package_name, ret);
 704     }
 705 #endif
 706
 707     sb_app_info = new CicoHSAppInfo(sb_package_name);
 708     ret = sb_app_info->Execute();
 709     if (ret < 0) {
 710         ICO_WRN("execute failed(%s) err=%d", sb_package_name, ret);
 711     }
 712     return ICO_OK;
 713 }
 714
 715 /*--------------------------------------------------------------------------*/
 716 /**
 717  * @brief   CicoHomeScreen::Initialize
 718  *          Initialize
 719  *
 720  * @param[in]   orientation    vertical or horizontal
 721  * @param[in]   config         config
 722  * @return      OK or ERROR
 723  */
 724 /*--------------------------------------------------------------------------*/
 725 int
 726 CicoHomeScreen::Initialize(int orientation,CicoHomeScreenConfig *config)
 727 {
 728
 729     ICO_DBG("CicoHomeScreen::Initialize: start");
 730     /*save instance pointer */
 731     hs_instance = this;
 732
 733     /*config copy*/
 734     this->config = config;
 735
 736     /* get pkg name (home screen,status bar,on screen)*/
 737     char *pkg;
 738     ICO_DBG("CicoHomeSceen::Initialize: %s: %s",
 739             getenv("HOME"), getenv("PKG_NAME"));
 740     pkg = getenv("PKG_NAME");
 741     memset(hs_package_name, 0, ICO_HS_MAX_PROCESS_NAME);
 742     if(pkg){
 743         strncpy(hs_package_name, pkg, ICO_HS_MAX_PROCESS_NAME);
 744     }
 745     else{
 746         strncpy(hs_package_name, ICO_HS_PROC_DEFAULT_HOMESCREEN,
 747                 ICO_HS_MAX_PROCESS_NAME);
 748     }
 749
 750     /* Initialize WindowController */
 751     CicoHSWindowController::Initialize();
 752     ICO_DBG("CicoHomeScreen::Initialize: window controller initialized");
 753
 754     ICO_DBG("CicoHomeScreen::Initialize: start connect to systemcontroller");
 755     ico_syc_connect(EventCallBack,NULL);
 756     ICO_DBG("CicoHomeScreen::Initialize: end connect to systemcontroller");
 757
 758     /*init lifecycle controller*/
 759     CicoSCSystemConfig::getInstance()->load(ICO_HS_LIFECYCLE_CONTROLLER_SETTING_PATH);
 760     life_cycle_controller = CicoSCLifeCycleController::getInstance();
 761
 762     /*initialize system controller*/
 763     /*my info*/
 764     ICO_DBG("CicoHomeScreen::Initialize: get package name %s",hs_package_name);
 765     hs_app_info = new CicoHSAppInfo(hs_package_name);
 766
 767     /*start home statusbar and onscreen*/
 768     StartRelations();
 769     ICO_DBG("CicoHomeScreen::Initialize: start relation apps");
 770
 771     /* Get screen size */
 772     CicoHSWindowController::GetFullScreenSize(orientation,
 773                                               &full_width,&full_height);
 774
 775     ICO_DBG("full screen size x=%d y=%d",full_width,full_height);
 776
 777     /* MenuScreen Window Size */
 778     menu_width = full_width;
 779     menu_height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
 780                   ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 781
 782     /* BackGround Window Size */
 783     bg_width = full_width;
 784     bg_height = full_height;
 785
 786     /* Control Bar Window Size */
 787     ctl_bar_width = full_width;
 788     ctl_bar_height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
 789
 790     ICO_DBG("CicoHomeScreen::Initialize: end");
 791
 792     return ICO_OK;
 793 }
 794
 795 /*--------------------------------------------------------------------------*/
 796 /**
 797  * @brief   CicoHomeScreen::Finalize
 798  *          Finalize
 799  *
 800  * @param[in]   none
 801  * @return      none
 802  */
 803 /*--------------------------------------------------------------------------*/
 804 void
 805 CicoHomeScreen::Finalize(void)
 806 {
 807     /* Finalize WindowController */
 808     CicoHSWindowController::Finalize();
 809
 810     ico_syc_disconnect();
 811
 812     delete hs_app_info;
 813 }
 814
 815 /*--------------------------------------------------------------------------*/
 816 /**
 817  * @brief   CicoHomeScreen::CreateMenuWindow
 818  *          create menu window
 819  *
 820  * @param[in]   none
 821  * @return      none
 822  */
 823 /*--------------------------------------------------------------------------*/
 824 void
 825 CicoHomeScreen::CreateMenuWindow(void)
 826 {
 827     /*create window*/
 828     menu_window = new CicoHSMenuWindow();
 829     menu_window->CreateMenuWindow(ICO_HS_WINDOW_POS_X,ICO_HS_WINDOW_POS_Y,
 830                                   menu_width,menu_height);
 831     menu_window->ShowWindow();
 832 }
 833
 834 /*--------------------------------------------------------------------------*/
 835 /**
 836  * @brief   CicoHomeScreen::DeleteMenuWindow
 837  *          delete menu window
 838  *
 839  * @param[in]   none
 840  * @return      none
 841  */
 842 /*--------------------------------------------------------------------------*/
 843 void
 844 CicoHomeScreen::DeleteMenuWindow(void)
 845 {
 846     if(menu_window == NULL){
 847         return;
 848     }
 849     menu_window->FreeMenuWindow();
 850     delete menu_window;
 851
 852 }
 853 /*--------------------------------------------------------------------------*/
 854 /**
 855  * @brief   CicoHomeScreen::UpdateMenuWindow
 856  *          update menu window
 857  *
 858  * @param[in]   none
 859  * @return      none
 860  */
 861 /*--------------------------------------------------------------------------*/
 862 void
 863 CicoHomeScreen::UpDateMenuWindow(void)
 864 {
 865     DeleteMenuWindow();
 866     CreateMenuWindow();
 867 }
 868
 869 /*--------------------------------------------------------------------------*/
 870 /**
 871  * @brief   CicoHomeScreen::CreateBackWindow
 872  *          create back window
 873  *
 874  * @param[in]   none
 875  * @return      none
 876  */
 877 /*--------------------------------------------------------------------------*/
 878 void
 879 CicoHomeScreen::CreateBackWindow(void)
 880 {
 881     /*create window*/
 882     back_window = new CicoHSBackWindow();
 883     back_window->CreateBackWindow(ICO_HS_WINDOW_POS_X,ICO_HS_WINDOW_POS_Y,
 884                                   bg_width,bg_height);
 885     back_window->ShowWindow();
 886 }
 887
 888 /*--------------------------------------------------------------------------*/
 889 /**
 890  * @brief   CicoHomeScreen::CreateBackWindow
 891  *          create back window
 892  *
 893  * @param[in]   none
 894  * @return      none
 895  */
 896 /*--------------------------------------------------------------------------*/
 897 void
 898 CicoHomeScreen::DeleteBackWindow(void)
 899 {
 900     if(back_window == NULL){
 901         return;
 902     }
 903     back_window->FreeBackWindow();
 904     delete back_window;
 905
 906 }
 907
 908 /*--------------------------------------------------------------------------*/
 909 /**
 910  * @brief   CicoHomeScreen::UpDateBackWindow
 911  *          update back window
 912  *
 913  * @param[in]   none
 914  * @return      none
 915  */
 916 /*--------------------------------------------------------------------------*/
 917 void
 918 CicoHomeScreen::UpDateBackWindow(void)
 919 {
 920     DeleteBackWindow();
 921     CreateBackWindow();
 922 }
 923
 924 /*--------------------------------------------------------------------------*/
 925 /**
 926  * @brief   CicoHomeScreen::CreateControlBarWindow
 927  *          create control bar window
 928  *
 929  * @param[in]   none
 930  * @return      none
 931  */
 932 /*--------------------------------------------------------------------------*/
 933 void
 934 CicoHomeScreen::CreateControlBarWindow(void)
 935 {
 936     /*create window*/
 937     ctl_bar_window = new CicoHSControlBarWindow();
 938     ctl_bar_window->CreateControlBarWindow(ICO_HS_MENU_WINDOW_POS_X,bg_height -
 939                                            ctl_bar_height,ctl_bar_width,
 940                                            ctl_bar_height);
 941     ctl_bar_window->ShowWindow();
 942 }
 943
 944 /*--------------------------------------------------------------------------*/
 945 /**
 946  * @brief   CicoHomeScreen::CreateControlBarWindow
 947  *          delete control bar window
 948  *
 949  * @param[in]   none
 950  * @return      none
 951  */
 952 /*--------------------------------------------------------------------------*/
 953 void
 954 CicoHomeScreen::DeleteControlBarWindow(void)
 955 {
 956     if(ctl_bar_window == NULL){
 957         return;
 958     }
 959     ctl_bar_window->FreeControlBarWindow();
 960     delete ctl_bar_window;
 961
 962 }
 963
 964 /*--------------------------------------------------------------------------*/
 965 /**
 966  * @brief   CicoHomeScreen::StartLoop
 967  *          start ecore loop
 968  *
 969  * @param[in]   none
 970  * @return      none
 971  */
 972 /*--------------------------------------------------------------------------*/
 973 void
 974 CicoHomeScreen::StartLoop(void)
 975 {
 976     CicoHSWindowController::StartEcoreLoop();
 977 }
 978
 979 /*--------------------------------------------------------------------------*/
 980 /**
 981  * @brief   CicoHomeScreen::StartHomeScreen
 982  *          start home screen
 983  *
 984  * @param[in]   none
 985  * @return      none
 986  */
 987 /*--------------------------------------------------------------------------*/
 988 void
 989 CicoHomeScreen::StartHomeScreen()
 990 {
 991     /*Get application info*/
 992     CreateAppInfoList();
 993
 994     /*Create window*/
 995     CreateBackWindow();
 996
 997     /*Create window*/
 998     CreateControlBarWindow();
 999
1000     /*Create window*/
1001     CreateMenuWindow();
1002
1003     /*Show Home Screen*/
1004     ShowHomeScreenLayer();
1005
1006     /* start loop*/
1007     StartLoop();
1008 }
1009
1010 /*--------------------------------------------------------------------------*/
1011 /**
1012  * @brief   CicoHomeScreen::GetMode
1013  *          Get status
1014  *
1015  * @param[in]   mode status
1016  * @return      none
1017  */
1018 /*--------------------------------------------------------------------------*/
1019 int
1020 CicoHomeScreen::GetMode(void)
1021 {
1022     return mode;
1023 }
1024 /*--------------------------------------------------------------------------*/
1025 /**
1026  * @brief   CicoHomeScreen::SetMode
1027  *          Set status
1028  *
1029  * @param[in]   mode status
1030  * @return      none
1031  */
1032 /*--------------------------------------------------------------------------*/
1033 void
1034 CicoHomeScreen::SetMode(int mode)
1035 {
1036     this->mode = mode;
1037 }
1038 /*--------------------------------------------------------------------------*/
1039 /**
1040  * @brief   CicoHomeScreen::ChangeMode
1041  *          Change status
1042  *
1043  * @param[in]   none
1044  * @return      none
1045  */
1046 /*--------------------------------------------------------------------------*/
1047 void
1048 CicoHomeScreen::ChangeMode(int pattern)
1049 {
1050     if(hs_instance->menu_window == NULL){
1051         return;
1052     }
1053
1054     if(hs_instance->GetMode() == ICO_HS_MODE_MENU){
1055         ico_syc_animation_t animation;
1056         if(pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE){
1057             animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1058         }else{
1059             animation.name = (char*)ICO_HS_MENU_HIDE_ANIMATION_FADE;
1060         }
1061         animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1062         hs_instance->menu_window->Hide(&animation);
1063         hs_instance->SetMode(ICO_HS_MODE_APPLICATION);
1064     }else if(hs_instance->GetMode() ==ICO_HS_MODE_APPLICATION){
1065         ico_syc_animation_t animation;
1066         if(pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE){
1067             animation.name = (char*)ICO_HS_MENU_SHOW_ANIMATION_SLIDE;
1068         }else{
1069             animation.name = (char*)ICO_HS_MENU_SHOW_ANIMATION_FADE;
1070         }
1071         animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1072         hs_instance->menu_window->Show(&animation);
1073         hs_instance->SetMode(ICO_HS_MODE_MENU);
1074     }
1075 }
1076 /*--------------------------------------------------------------------------*/
1077 /**
1078  * @brief   CicoHomeScreen::ExecuteApp
1079  *          execute application
1080  *
1081  * @param[in]   appid
1082  * @return      none
1083  */
1084 /*--------------------------------------------------------------------------*/
1085 void
1086 CicoHomeScreen::ExecuteApp(const char*appid)
1087 {
1088     hs_instance->ExecuteApp_i(appid);
1089 }
1090 /*--------------------------------------------------------------------------*/
1091 /**
1092  * @brief   CicoHomeScreen::TerminateApp
1093  *          teminate application
1094  *
1095  * @param[in]   appid
1096  * @return      none
1097  */
1098 /*--------------------------------------------------------------------------*/
1099 void
1100 CicoHomeScreen::TerminateApp(const char*appid)
1101 {
1102     hs_instance->TerminateApp_i(appid);
1103 }
1104 // vim: set expandtab ts=4 sw=4: