2 * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
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
17 #include "CicoHSAppHistory.h"
18 #include "CicoHSAppHistoryExt.h"
19 #include "CicoHomeScreen.h"
20 #include "CicoHSSystemState.h"
21 #include "CicoHSLifeCycleController.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"
31 /*============================================================================*/
33 /*============================================================================*/
34 CicoHomeScreen * CicoHomeScreen::hs_instance;
36 /*============================================================================*/
38 /*============================================================================*/
41 * ecore timer void data typedef
43 typedef struct t_launcApps_data {
49 /*--------------------------------------------------------------------------*/
51 * @brief CicoHomeScreen::CicoHomeScreen
57 /*--------------------------------------------------------------------------*/
58 CicoHomeScreen::CicoHomeScreen(void)
61 for(int ii = 0;ii < ICO_HS_MAX_APP_NUM;ii++){
64 active_appinfo = NULL;
78 num_swipe_input_windows = 0;
82 ctl_bar_window = NULL;
84 //mode = ICO_HS_MODE_MENU;
85 mode = ICO_HS_MODE_APPLICATION;
91 life_cycle_controller = CicoHSLifeCycleController::getInstance();
93 sub_display_appinfo = NULL;
96 /*--------------------------------------------------------------------------*/
98 * @brief CicoHomeScreen::~CicoHomeScreen
104 /*--------------------------------------------------------------------------*/
105 CicoHomeScreen::~CicoHomeScreen(void)
107 /* Do not somthing to do */
108 if (NULL != m_appHis) {
113 //--------------------------------------------------------------------------
115 * @brief get this class instance
117 //--------------------------------------------------------------------------
119 CicoHomeScreen::getInstance(void)
124 /*--------------------------------------------------------------------------*/
126 * @brief CicoHomeScreen::ShowHomeScreenLayer
127 * Show Home screen layer
132 /*--------------------------------------------------------------------------*/
134 CicoHomeScreen::ShowHomeScreenLayer(void)
136 /*show home screen layers*/
137 ico_syc_show_layer(HS_LAYER_APPLICATION);
138 ico_syc_show_layer(HS_LAYER_HOMESCREEN);
139 ico_syc_show_layer(HS_LAYER_CONTROLBAR);
140 ico_syc_show_layer(HS_LAYER_TOUCHPANEL);
143 /*--------------------------------------------------------------------------*/
145 * @brief CicoHomeScreen::GetHsPackageName
146 * get HomeScreen package name
149 * @return package name
151 /*--------------------------------------------------------------------------*/
153 CicoHomeScreen::GetHsPackageName(void)
155 return hs_package_name;
158 /*--------------------------------------------------------------------------*/
160 * @brief CicoHomeScreen::GetHsPackageName
161 * get StatusBar package name
164 * @return package name
166 /*--------------------------------------------------------------------------*/
168 CicoHomeScreen::GetSbPackageName(void)
170 return sb_package_name;
173 /*--------------------------------------------------------------------------*/
175 * @brief CicoHomeScreen::GetHsPackageName
176 * get OnScreen package name
179 * @return package name
181 /*--------------------------------------------------------------------------*/
183 CicoHomeScreen::GetOsPackageName(void)
185 return os_package_name;
188 /*--------------------------------------------------------------------------*/
190 * @brief CicoHomeScreen::CreateAppInfoList
191 * create application info list
196 /*--------------------------------------------------------------------------*/
198 CicoHomeScreen::CreateAppInfoList(void)
200 /* get APP information*/
201 std::vector<CicoAilItems> aillist = life_cycle_controller->getAilList();
203 for (int ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
204 if (apps_info[ii] != NULL) {
205 delete apps_info[ii];
211 for (unsigned int ii = 0;
212 (ii < aillist.size()) && (ii < ICO_HS_MAX_APP_NUM);
214 apps_info[ii] = new CicoHSAppInfo(aillist[ii].m_appid.c_str());
219 /*--------------------------------------------------------------------------*/
221 * @brief CicoHomeScreen::GetAppInfo
222 * get application info
224 * @param[in] appid application id
225 * @return Application info
227 /*--------------------------------------------------------------------------*/
229 CicoHomeScreen::GetAppInfo(const char *appid)
235 for (int ii = 0;ii < hs_instance->application_num;ii++) {
236 if (strcmp(hs_instance->apps_info[ii]->GetAppId(),appid) == 0) {
237 return hs_instance->apps_info[ii];
243 /*--------------------------------------------------------------------------*/
245 * @brief CicoHomeScreen::GetAppStatus
246 * get application status
248 * @param[in] appid application id
249 * @return Application info
251 /*--------------------------------------------------------------------------*/
253 CicoHomeScreen::GetAppStatus(const char *appid)
255 for (int ii = 0;ii < hs_instance->application_num;ii++) {
256 if (strcmp(hs_instance->apps_info[ii]->GetAppId(),appid) == 0) {
257 return hs_instance->apps_info[ii]->GetStatus();
263 /*--------------------------------------------------------------------------*/
265 * @brief change active window
267 /*--------------------------------------------------------------------------*/
269 CicoHomeScreen::ChangeActive(const char * appid, int surface)
271 CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(appid);
272 if (appinfo == NULL) {
276 ico_hs_window_info* wininfo = appinfo->GetWindowInfobySurface(surface);
277 if (wininfo == NULL) {
281 appinfo->SetLastSurface(surface);
283 // if window invisible, not update active information
284 if (0 != wininfo->visible) {
285 hs_instance->SetActiveAppInfo(appid);
286 hs_instance->setActiveApp(appid);
287 ICO_TRA("CicoHomeScreen::ChangeActive set show");
288 ico_syc_show(appid, surface, NULL);
289 ico_syc_change_active(appid, surface);
293 /*--------------------------------------------------------------------------*/
295 * @brief change application display zone for active window
297 /*--------------------------------------------------------------------------*/
299 CicoHomeScreen::ChangeZone(void)
301 ICO_TRA("CicoHomeScreen::ChangeZone Enter");
303 hs_instance->controlRegulation();
305 CicoHSAppInfo* appinfo = hs_instance->GetSubDisplayAppInfo();
306 // if sub display not exist showed appliction,
307 // get main display showed application informaiton
308 if (NULL == appinfo) {
309 appinfo = hs_instance->GetActiveAppInfo();
310 if (NULL == appinfo) {
311 ICO_TRA("CicoHomeScreen::ChangeZone Leave(not found appinfo)");
315 hs_instance->requestChangeZone(appinfo);
316 ICO_TRA("CicoHomeScreen::ChangeZone Leave");
319 /*--------------------------------------------------------------------------*/
321 * @brief change application display zone for appinfo
323 /*--------------------------------------------------------------------------*/
325 CicoHomeScreen::requestChangeZone(CicoHSAppInfo* appinfo)
327 int surface = appinfo->GetLastSurface();
328 ICO_TRA("Enter appid=%s, lastsurface=%x", appinfo->GetAppId(), surface);
329 ico_hs_window_info* wininfo = appinfo->GetWindowInfobySurface(surface);
330 if (NULL == wininfo) {
331 ICO_TRA("Leave(not found wininfo)");
334 ICO_DBG("wininfo=%p", wininfo);
336 const char *dispzone = moveZoneName;
337 int layer = HS_LAYER_2NDDISP_APP;
338 if (NULL != GetSubDisplayAppInfo()) {
339 dispzone = appinfo->GetDefaultZone();
340 layer = HS_LAYER_APPLICATION;
343 if (NULL == dispzone) {
344 ICO_TRA("Leave(not found dispzone)");
348 ICO_DBG("change zone: \"%s\"->\"%s\"", wininfo->zone, dispzone);
349 ico_syc_win_move_t move;
350 move.zone = dispzone;
357 ico_syc_move(wininfo->appid, wininfo->surface, &move,
358 &hs_instance->moveZoneAnimation);
363 /*--------------------------------------------------------------------------*/
365 * @brief CicoHomeScreen::GetWindowInfo
368 * @param[in] appinfo application info
369 * @param[in] window window name
370 * @return Window info
372 /*--------------------------------------------------------------------------*/
374 CicoHomeScreen::GetWindowInfo(CicoHSAppInfo *appinfo,const char *window)
376 return appinfo->GetWindowInfo(window);
379 /*--------------------------------------------------------------------------*/
381 * @brief CicoHomeScreen::GetWindowInfo
384 * @param[in] appinfo application info
385 * @param[in] surface surface id
386 * @return Window info
388 /*--------------------------------------------------------------------------*/
390 CicoHomeScreen::GetWindowInfo(CicoHSAppInfo *appinfo, int surface)
392 return appinfo->GetWindowInfobySurface(surface);
395 /*--------------------------------------------------------------------------*/
397 * @brief CicoHomeScreen::UpdateTile
400 * @param[in] appid application id
401 * @return Window info
403 /*--------------------------------------------------------------------------*/
405 CicoHomeScreen::UpdateTile(const char *appid)
407 CicoHSAppInfo *appinfo = GetAppInfo(appid);
408 if (appinfo == NULL) {
411 if (appinfo->GetStatus() == false) {
413 ICO_DBG("CicoHomeScreen::UpdateTile: show menuIcon(%s)", appid);
414 menu_window->ValidMenuIcon(appid);
418 ICO_DBG("CicoHomeScreen::UpdateTile: show app thumbnail(%s)", appid);
419 menu_window->ValidThumbnail(appid, appinfo->GetLastSurface());
423 /*--------------------------------------------------------------------------*/
425 * @brief set current active application information
427 * @param [in] appid application id
429 /*--------------------------------------------------------------------------*/
431 CicoHomeScreen::SetActiveAppInfo(const char *appid)
433 CicoHSAppInfo* appinfo = NULL;
435 appinfo = GetAppInfo(appid);
437 // if active window is HomeScreen/StatusBar/OnScreen,
438 // not update active application information
439 ICO_DBG("appinfo=%08x hs_app_info=%08x sb_app_info=%08x os_app_info=%08x",
440 appinfo, hs_app_info, sb_app_info, os_app_info);
441 if ((appinfo == hs_app_info) ||
442 (appinfo == sb_app_info) ||
443 (appinfo == os_app_info)) {
447 ICO_DBG("active application changed. \"%s\"->\"%s\"",
448 active_appinfo ? active_appinfo->GetAppId() : "unknown",
449 appinfo ? appinfo->GetAppId() : "unknown");
451 active_appinfo = appinfo;
454 /*--------------------------------------------------------------------------*/
456 * @brief update current active application information
458 * @param [in] appid application id
460 /*--------------------------------------------------------------------------*/
462 CicoHomeScreen::GetActiveAppInfo(void)
464 return active_appinfo;
467 /*--------------------------------------------------------------------------*/
469 * @brief set current sub display application information
471 * @param [in] appid application id
473 /*--------------------------------------------------------------------------*/
475 CicoHomeScreen::SetSubDisplayAppInfo(const char *appid)
478 if (NULL == sub_display_appinfo) {
479 ICO_WRN("already not use");
482 ICO_DBG("sub display appinfo changed. \"%s\"->\"none\"",
483 sub_display_appinfo->GetAppId());
484 sub_display_appinfo = NULL;
488 // if sub_display_appinfo is not NULL,
489 // not update sub display application information
490 if (NULL != sub_display_appinfo) {
491 ICO_WRN("sub display use. appid=%s",
492 sub_display_appinfo->GetAppId());
496 CicoHSAppInfo* appinfo = GetAppInfo(appid);
498 // if sub display appinfo is HomeScreen/StatusBar/OnScreen,
499 // not update sub display application information
500 ICO_DBG("appinfo=%08x hs_app_info=%08x sb_app_info=%08x os_app_info=%08x",
501 appinfo, hs_app_info, sb_app_info, os_app_info);
502 if ((appinfo == hs_app_info) ||
503 (appinfo == sb_app_info) ||
504 (appinfo == os_app_info)) {
508 if (NULL != appinfo) {
509 ICO_DBG("sub display appinfo changed. \"none\"->\"%s\"",
510 appinfo->GetAppId());
511 sub_display_appinfo = appinfo;
515 /*--------------------------------------------------------------------------*/
517 * @brief update current sub display application information
520 /*--------------------------------------------------------------------------*/
522 CicoHomeScreen::GetSubDisplayAppInfo(void)
524 return sub_display_appinfo;
527 /*--------------------------------------------------------------------------*/
529 * @brief update current sub display application appid
531 * @return appid application id
532 * @retval NULL : sub display application nothing
533 * @retval not NULL : appid
535 /*--------------------------------------------------------------------------*/
537 CicoHomeScreen::GetSubDisplayAppid(void)
539 if (NULL == sub_display_appinfo) {
542 const char* pR = sub_display_appinfo->GetAppId();
543 if ((NULL == pR) || (0 == pR) || (0 == strlen(pR))) {
548 /*--------------------------------------------------------------------------*/
550 * @brief CicoHomeScreen::ExecuteApp_i
551 * execute and showing application
553 * @param[in] appid application id
556 /*--------------------------------------------------------------------------*/
558 CicoHomeScreen::ExecuteApp_i(const char *appid)
560 ICO_TRA("start %s", appid);
561 CicoHSAppInfo *appinfo = GetAppInfo(appid);
562 if (appinfo == NULL) {
563 ICO_TRA("end get appinfo is NULL");
566 if (sub_display_appinfo != appinfo) {
567 if (appinfo->GetStatus() == false) {
570 ICO_DBG("execute app %s", appid);
574 RaiseApplicationWindow(appinfo->GetAppId(),
575 appinfo->GetLastSurface());
576 ICO_DBG("raise app %s", appid);
577 m_appHis->moveHistoryHead(appid);
580 /* hide HomeScreen layer */
581 if (GetMode() == ICO_HS_MODE_MENU) {
582 ChangeMode(ICO_HS_SHOW_HIDE_PATTERN_FADE);
587 /*--------------------------------------------------------------------------*/
589 * @brief CicoHomeScreen::TerminateApp_i
590 * teminate application
592 * @param[in] appid application id
595 /*--------------------------------------------------------------------------*/
597 CicoHomeScreen::TerminateApp_i(const char *appid)
600 CicoHSAppInfo *appinfo = GetAppInfo(appid);
601 if (appinfo == NULL) {
606 appinfo->Terminate();
608 /* hide HomeScreen layer */
609 if (GetMode() == ICO_HS_MODE_MENU) {
610 ChangeMode(ICO_HS_SHOW_HIDE_PATTERN_FADE);
614 /*--------------------------------------------------------------------------*/
616 * @brief CicoHomeScreen::ShowHomeScreenWindow
617 * show window (home screen)
619 * @param[in] win info window information
622 /*--------------------------------------------------------------------------*/
624 CicoHomeScreen::ShowHomeScreenWindow(ico_syc_win_info_t *win_info)
626 ico_syc_win_move_t move;
630 move.width = full_width;
632 if (strncmp(win_info->name,ICO_HS_BACK_WINDOW_TITLE,
633 ICO_MAX_TITLE_NAME_LEN) == 0) {
634 move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
635 move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
636 ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
637 layer = HS_LAYER_BACKGROUND;
639 else if (strncmp(win_info->name,ICO_HS_CONTROL_BAR_WINDOW_TITLE,
640 ICO_MAX_TITLE_NAME_LEN) == 0) {
641 move.pos_y = full_height - ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
642 move.height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
643 layer = HS_LAYER_CONTROLBAR;
645 else if (strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
646 ICO_MAX_TITLE_NAME_LEN) == 0) {
647 move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
648 move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
649 ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
650 layer = HS_LAYER_HOMESCREEN;
657 ico_syc_change_layer(win_info->appid,win_info->surface,layer);
658 ICO_DBG("CicoHomeScreen::ShowHomeScreenWindow: id(%s) name(%s) surface(%d) "
659 "pos(%d,%d) size(%d,%d)", win_info->appid,
660 win_info->name, win_info->surface, move. pos_x, move.pos_y,
661 move.width, move.height);
662 ico_syc_move(win_info->appid, win_info->surface, &move, NULL);
664 /*first time menu is unvisible*/
665 if ((strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
666 ICO_MAX_TITLE_NAME_LEN) == 0) &&
667 (GetMode() == ICO_HS_MODE_APPLICATION)) {
670 ico_syc_show(win_info->appid, win_info->surface,NULL);
673 /*--------------------------------------------------------------------------*/
675 * @brief CicoHomeScreen::ShowStatusBarWindow
676 * show window (home screen)
678 * @param[in] win info window information
681 /*--------------------------------------------------------------------------*/
683 CicoHomeScreen::ShowStatusBarWindow(ico_syc_win_info_t *win_info)
685 ico_syc_win_move_t move;
690 move.width = full_width;
691 move.height = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
692 layer = HS_LAYER_CONTROLBAR;
694 ico_syc_change_layer(win_info->appid,win_info->surface,layer);
695 ICO_DBG("CicoHomeScreen::ShowStatusBarWindow: id(%s) name(%s) surface(%d) "
696 "pos(%d,%d) size(%d,%d)",win_info->appid,
697 win_info->name,win_info->surface,move.pos_x,move.pos_y,
698 move.width,move.height);
699 ico_syc_move(win_info->appid,win_info->surface,&move,NULL);
700 ico_syc_show(win_info->appid, win_info->surface,NULL);
703 /*--------------------------------------------------------------------------*/
705 * @brief CicoHomeScreen::ShowApplicationWindow
706 * show window (application)
708 * @param[in] win info window information
711 /*--------------------------------------------------------------------------*/
713 CicoHomeScreen::ShowApplicationWindow(ico_syc_win_info_t *win_info)
715 ICO_TRA("CicoHomeScreen::ShowApplicationWindow Enter");
717 CicoHSLifeCycleController *lifecycle =
718 CicoHSLifeCycleController::getInstance();
719 const CicoAilItems* ailItem = lifecycle->findAIL(win_info->appid);
720 if (NULL == ailItem) {
721 ICO_WRN("ailItem not found.");
722 ICO_TRA("CicoHomeScreen::ShowApplicationWindow Leave");
725 int zoneid = ailItem->m_displayZone;
727 ICO_DBG("zoneid=%d", zoneid);
728 const CicoSCDisplayZoneConf* dispZoneConf =
729 CicoSystemConfig::getInstance()->findDisplayZoneConfbyId(zoneid);
730 if (NULL == dispZoneConf) {
731 ICO_WRN("display zone config not found.");
732 ICO_TRA("CicoHomeScreen::ShowApplicationWindow Leave");
735 ICO_DBG("appid=%s zoneid=%d:%s",
736 win_info->appid, zoneid, dispZoneConf->fullname.c_str());
738 ico_syc_win_move_t move;
740 move.zone = dispZoneConf->fullname.c_str();
741 move.layer = HS_LAYER_APPLICATION;
742 if (ailItem->m_display != 0) {
743 move.layer = HS_LAYER_2NDDISP_APP;
746 move.width = full_width;
747 move.pos_y = ICO_HS_STATUSBAR_WINDOW_HEIGHT;
748 move.height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
749 ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
751 ico_syc_move(win_info->appid,win_info->surface,&move,NULL);
752 ico_syc_animation_t animation;
753 animation.name = ICO_HS_MENU_HIDE_ANIMATION_FADE;
754 animation.time = ICO_HS_MENU_ANIMATION_DURATION;
755 const string& lastStartupApp = m_appHis->getLastStartupAppid();
756 if (true == lastStartupApp.empty()) {
757 ICO_DBG("show (empty) %s", win_info->appid);
758 ico_syc_show(win_info->appid, win_info->surface, &animation);
762 if (0 == lastStartupApp.compare(win_info->appid)) {
766 ICO_DBG("show (last) %s", win_info->appid);
767 ico_syc_show(win_info->appid, win_info->surface, &animation);
770 ICO_DBG("hide (no last) %s", win_info->appid);
771 ico_syc_hide(win_info->appid, win_info->surface, &animation);
774 ICO_TRA("CicoHomeScreen::ShowApplicationWindow Leave");
777 /*--------------------------------------------------------------------------*/
779 * @brief CicoHomeScreen::RaiseApplicationWindow
780 * raise window (application)
782 * @param[in] appid application id
783 * @param[in] surface surface
786 /*--------------------------------------------------------------------------*/
788 CicoHomeScreen::RaiseApplicationWindow(const char *appid,int surface)
790 ico_syc_show(appid, surface, NULL);
791 ico_syc_change_active(appid, surface);
792 hs_instance->SetActiveAppInfo(appid);
795 /*--------------------------------------------------------------------------*/
797 * @brief CicoHomeScreen::EventCallBack
798 * callback for system controller
800 * @param[in] event kind of event
801 * @param[in] detail detail
802 * @param[in] user_data user data
805 /*--------------------------------------------------------------------------*/
807 CicoHomeScreen::EventCallBack(const ico_syc_ev_e event,
808 const void *detail,void *user_data)
812 // ICO_DBG("CicoHomeScreen::EventCallBack: start (event %d)",event);
814 if (event == ICO_SYC_EV_WIN_CREATE) {
815 ico_syc_win_info_t *win_info =
816 reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
817 ICO_DBG("Event:ICO_SYC_EV_WIN_CREATE(appid=%s surface=%08x)",
818 win_info->appid, win_info->surface);
819 /*only save information*/
820 if (strncmp(win_info->appid, hs_instance->GetHsPackageName(),
821 ICO_HS_MAX_PROCESS_NAME) == 0) {
823 hs_instance->hs_app_info->AddWindowInfo(win_info);
826 if (strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
827 ICO_MAX_TITLE_NAME_LEN) == 0) {
828 hs_instance->menu_window->SetMenuWindowID(win_info->appid,
831 else if (strncmp(win_info->name,ICO_HS_CONTROL_BAR_WINDOW_TITLE,
832 ICO_MAX_TITLE_NAME_LEN) == 0) {
833 hs_instance->ctl_bar_window->SetWindowID(win_info->appid,
837 if (win_info->name[0] == 0) {
838 /* null name, nothing to do */
841 for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++) {
842 if (hs_instance->swipe_input_windows[idx]->
843 isMyWindowName(win_info->name)) {
844 hs_instance->swipe_input_windows[idx]->
845 SetWindowID(win_info->appid, win_info->surface);
846 hs_instance->swipe_input_windows[idx]->SetupSwipeWindow();
852 hs_instance->ShowHomeScreenWindow(win_info);
854 else if (strncmp(win_info->appid,
855 hs_instance->GetSbPackageName(),
856 ICO_HS_MAX_PROCESS_NAME) == 0) {
858 hs_instance->sb_app_info->AddWindowInfo(win_info);
861 hs_instance->ShowStatusBarWindow(win_info);
863 else if (strncmp(win_info->appid,
864 hs_instance->GetOsPackageName(),
865 ICO_HS_MAX_PROCESS_NAME) == 0) {
868 hs_instance->os_app_info->AddWindowInfo(win_info);
870 // change the layer of onscreen window
871 ico_syc_change_layer(win_info->appid, win_info->surface,
874 const CicoSCPositionOSConf* oPOSC =
875 CicoSystemConfig::getInstance()->positionOSConf();
876 ico_syc_win_move_t move;
878 move.layer = HS_LAYER_ONSCREEN;
879 move.pos_x = oPOSC->m_x;
880 move.pos_y = oPOSC->m_y;
881 move.width = oPOSC->m_w;
882 move.height = oPOSC->m_h;
883 ico_syc_animation_t animation;
884 animation.name = ICO_HS_MENU_SHOW_ANIMATION_SLIDE;
885 animation.time = ICO_HS_MENU_ANIMATION_DURATION;
886 ico_syc_move(win_info->appid, win_info->surface, &move, &animation);
891 CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(win_info->appid);
892 if (appinfo == NULL) {
895 appinfo->AddWindowInfo(win_info);
897 appinfo->SetLastSurface(win_info->surface);
898 hs_instance->ShowApplicationWindow(win_info);
899 ico_syc_change_active(win_info->appid,win_info->surface);
900 hs_instance->SetActiveAppInfo(win_info->appid);
901 hs_instance->UpdateTile(win_info->appid);
903 hs_instance->startupCheck(win_info->appid);
906 else if (event == ICO_SYC_EV_WIN_NAME) {
907 ico_syc_win_info_t *win_info =
908 reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
909 ICO_DBG("Event:ICO_SYC_EV_WIN_NAME(appid=%s surface=%08x name=%s)",
910 win_info->appid, win_info->surface, win_info->name);
912 if (strncmp(win_info->appid, hs_instance->GetHsPackageName(),
913 ICO_HS_MAX_PROCESS_NAME) == 0) {
915 hs_instance->hs_app_info->AddWindowInfo(win_info);
918 if (strncmp(win_info->name,ICO_HS_MENU_WINDOW_TITLE,
919 ICO_MAX_TITLE_NAME_LEN) == 0) {
920 hs_instance->menu_window->SetMenuWindowID(win_info->appid,
923 else if (strncmp(win_info->name,ICO_HS_CONTROL_BAR_WINDOW_TITLE,
924 ICO_MAX_TITLE_NAME_LEN) == 0) {
925 hs_instance->ctl_bar_window->SetWindowID(win_info->appid,
929 for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++) {
930 if (hs_instance->swipe_input_windows[idx]->
931 isMyWindowName(win_info->name)) {
932 hs_instance->swipe_input_windows[idx]->
933 SetWindowID(win_info->appid, win_info->surface);
934 hs_instance->swipe_input_windows[idx]->SetupSwipeWindow();
941 hs_instance->ShowHomeScreenWindow(win_info);
943 else if (strncmp(win_info->appid, hs_instance->GetSbPackageName(),
944 ICO_HS_MAX_PROCESS_NAME) == 0) {
946 hs_instance->sb_app_info->AddWindowInfo(win_info);
948 else if (strncmp(win_info->appid, hs_instance->GetOsPackageName(),
949 ICO_HS_MAX_PROCESS_NAME) == 0) {
951 hs_instance->os_app_info->AddWindowInfo(win_info);
955 CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(win_info->appid);
956 if (appinfo == NULL) {
959 appinfo->AddWindowInfo(win_info);
962 else if (event == ICO_SYC_EV_WIN_DESTROY) {
963 ico_syc_win_info_t *win_info =
964 reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
965 ICO_DBG("Event:ICO_SYC_EV_WIN_DESTROY(appid=%s surface=%08x)",
966 win_info->appid, win_info->surface);
967 /*only save information*/
968 if (strncmp(win_info->appid, hs_instance->GetHsPackageName(),
969 ICO_HS_MAX_PROCESS_NAME) == 0) {
970 hs_instance->hs_app_info->FreeWindowInfo(win_info->name);
972 else if (strncmp(win_info->appid,
973 hs_instance->GetSbPackageName(),
974 ICO_HS_MAX_PROCESS_NAME) == 0) {
975 hs_instance->sb_app_info->FreeWindowInfo(win_info->name);
977 else if (strncmp(win_info->appid,
978 hs_instance->GetOsPackageName(),
979 ICO_HS_MAX_PROCESS_NAME) == 0) {
980 hs_instance->os_app_info->FreeWindowInfo(win_info->name);
984 CicoHSAppInfo *appinfo =
985 hs_instance->GetAppInfo(win_info->appid);
986 if (appinfo == NULL) {
989 appinfo->FreeWindowInfo(win_info->surface);
990 hs_instance->UpdateTile(win_info->appid);
992 // update active application information
993 CicoHSAppInfo *active_appinfo = hs_instance->GetActiveAppInfo();
994 if (appinfo == active_appinfo) {
995 hs_instance->SetActiveAppInfo(NULL);
998 // update sub displayed application information
999 CicoHSAppInfo *subdisp_appinfo = hs_instance->GetSubDisplayAppInfo();
1000 if (appinfo == subdisp_appinfo) {
1001 hs_instance->SetSubDisplayAppInfo(NULL);
1005 else if (event == ICO_SYC_EV_WIN_ACTIVE) {
1006 ico_syc_win_info_t *win_info =
1007 reinterpret_cast<ico_syc_win_info_t*>(const_cast<void*>(detail));
1008 ICO_DBG("Event:ICO_SYC_EV_WIN_ACTIVE(appid=%s surface=%08x)",
1009 win_info->appid, win_info->surface);
1010 hs_instance->ChangeActive(win_info->appid, win_info->surface);
1012 else if (event == ICO_SYC_EV_WIN_ATTR_CHANGE) {
1013 ico_syc_win_attr_t *win_attr =
1014 reinterpret_cast<ico_syc_win_attr_t*>(const_cast<void*>(detail));
1015 ICO_DBG("Event:ICO_SYC_EV_WIN_ATTR_CHANGE(appid=%s surface=%08x)",
1016 win_attr->appid, win_attr->surface);
1017 if (strncmp(win_attr->appid, hs_instance->GetHsPackageName(),
1018 ICO_HS_MAX_PROCESS_NAME) == 0) {
1020 hs_instance->hs_app_info->AddWindowAttr(win_attr);
1022 else if (strncmp(win_attr->appid, hs_instance->GetSbPackageName(),
1023 ICO_HS_MAX_PROCESS_NAME) == 0) {
1025 hs_instance->sb_app_info->AddWindowAttr(win_attr);
1027 else if (strncmp(win_attr->appid, hs_instance->GetOsPackageName(),
1028 ICO_HS_MAX_PROCESS_NAME) == 0) {
1030 hs_instance->os_app_info->AddWindowAttr(win_attr);
1033 ICO_DBG("CicoHomeScreen::EventCallBack : application window %s %s",
1034 win_attr->appid,win_attr->name);
1036 CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(win_attr->appid);
1037 if (appinfo == NULL) {
1041 // change layer when moved zone in second display
1042 ico_hs_window_info *winfo = NULL;
1043 winfo = appinfo->GetWindowInfobySurface(win_attr->surface);
1044 if (NULL != winfo) {
1045 if (win_attr->nodeid != winfo->nodeid) {
1046 if (0 == win_attr->nodeid) {
1047 if (NULL != hs_instance->GetSubDisplayAppInfo()) {
1048 if (hs_instance->m_appHis) {
1049 const string& wapp = hs_instance->m_appHis->getSelectApp();
1050 ICO_DBG("\"%s\"->\"%s\"", wapp.c_str(), winfo->appid);
1051 if ((false == wapp.empty()) &&
1052 (0 != wapp.compare(winfo->appid))) {
1053 hs_instance->requestHideAppid(wapp);
1054 hs_instance->m_appHis->clearSelectApp();
1055 hs_instance->m_appHis->homeSwipe();
1058 ICO_DBG("reset sub display");
1059 hs_instance->SetSubDisplayAppInfo(NULL);
1060 hs_instance->ChangeActive(winfo->appid, winfo->surface);
1064 ICO_DBG("set sub display");
1065 hs_instance->SetSubDisplayAppInfo(winfo->appid);
1068 if (hs_instance->m_appHis) {
1069 if (true == hs_instance->m_appHis->chgChk()) {
1070 hs_instance->m_appHis->writeAppHistory();
1072 hs_instance->m_appHis->homeSwipe();
1077 // update window information
1078 appinfo->AddWindowAttr(win_attr);
1079 hs_instance->UpdateTile(win_attr->appid);
1082 else if (event == ICO_SYC_EV_THUMB_CHANGE) {
1083 ico_syc_thumb_info_t *thumb_info =
1084 reinterpret_cast<ico_syc_thumb_info_t*>(const_cast<void*>(detail));
1085 CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(thumb_info->appid);
1086 if (appinfo == NULL) {
1087 ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_CHANGE %s(%02x) "
1088 "no appinfo", thumb_info->appid, thumb_info->surface);
1091 // ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_CHANGE %s(%02x)",
1092 // thumb_info->appid, thumb_info->surface);
1093 // show thumbnail icon
1094 hs_instance->menu_window->SetThumbnail(thumb_info->appid, thumb_info);
1096 else if (event == ICO_SYC_EV_THUMB_UNMAP) {
1097 ico_syc_thumb_info_t *thumb_info =
1098 reinterpret_cast<ico_syc_thumb_info_t*>(const_cast<void*>(detail));
1099 CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(thumb_info->appid);
1100 if (appinfo == NULL) {
1101 ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_UNMAP %s(%02x) "
1102 "no appinfo", thumb_info->appid, thumb_info->surface);
1105 ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_UNMAP %s(%02x)",
1106 thumb_info->appid, thumb_info->surface);
1107 hs_instance->menu_window->SetThumbnail(thumb_info->appid, NULL);
1109 else if (event == ICO_SYC_EV_THUMB_ERROR) {
1110 ico_syc_thumb_info_t *thumb_info =
1111 reinterpret_cast<ico_syc_thumb_info_t*>(const_cast<void*>(detail));
1112 CicoHSAppInfo *appinfo = hs_instance->GetAppInfo(thumb_info->appid);
1113 if (appinfo == NULL) {
1114 ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_ERROR %s(%02x) "
1115 "no appinfo", thumb_info->appid, thumb_info->surface);
1118 ICO_DBG("CicoHomeScreen::EventCallBack : ICO_SYC_EV_THUMB_ERROR %s(%02x)",
1119 thumb_info->appid, thumb_info->surface);
1120 hs_instance->menu_window->SetThumbnail(thumb_info->appid, NULL);
1122 else if (event == ICO_SYC_EV_LAYER_ATTR_CHANGE) {
1125 else if (event == ICO_SYC_EV_USERLIST) {
1128 else if (event == ICO_SYC_EV_AUTH_FAIL) {
1131 else if (event == ICO_SYC_EV_RES_ACQUIRE) {
1134 else if (event == ICO_SYC_EV_RES_DEPRIVE) {
1137 else if (event == ICO_SYC_EV_RES_WAITING) {
1140 else if (event == ICO_SYC_EV_RES_REVERT) {
1143 else if (event == ICO_SYC_EV_RES_RELEASE) {
1146 else if (event == ICO_SYC_EV_INPUT_SET) {
1149 else if (event == ICO_SYC_EV_INPUT_UNSET) {
1152 else if (event == ICO_SYC_EV_STATE_CHANGE) {
1153 ico_syc_state_info_t *state_info =
1154 reinterpret_cast<ico_syc_state_info_t*>(const_cast<void*>(detail));
1155 ICO_DBG("EVENT:ICO_SYC_EV_STATE_CHANGE(id=%d state=%d)",
1156 state_info->id, state_info->state);
1157 if (ICO_SYC_STATE_REGULATION == state_info->id) {
1158 // set regulation state
1159 CicoHSSystemState::getInstance()->setRegulation(
1160 (state_info->state == ICO_SYC_STATE_ON) ? true : false);
1161 ecore_main_loop_thread_safe_call_async(CicoHomeScreen::SetRegulation, NULL);
1163 else if (ICO_SYC_STATE_NIGHTMODE == state_info->id) {
1164 // set night mode state
1165 CicoHSSystemState::getInstance()->setNightMode(
1166 (state_info->state == ICO_SYC_STATE_ON) ? true : false);
1167 ecore_main_loop_thread_safe_call_async(CicoHomeScreen::SetNightMode, NULL);
1170 // ICO_DBG("CicoHomeScreen::EventCallBack: end");
1173 /*--------------------------------------------------------------------------*/
1175 * @brief CicoHomeScreen::StartRelations
1176 * Execute Onscreen and Statusbar
1181 /*--------------------------------------------------------------------------*/
1183 CicoHomeScreen::StartRelations(void)
1186 strncpy(sb_package_name,
1187 config->ConfigGetString(ICO_HS_CONFIG_HOMESCREEN,
1189 ICO_HS_APPID_DEFAULT_SB),
1190 ICO_HS_MAX_PROCESS_NAME);
1191 strncpy(os_package_name,
1192 config->ConfigGetString(ICO_HS_CONFIG_HOMESCREEN,
1194 ICO_HS_APPID_DEFAULT_ONS),
1195 ICO_HS_MAX_PROCESS_NAME);
1198 /* start onscreen & statusbar apps */
1199 os_app_info = GetAppInfo(os_package_name);
1200 ret = os_app_info->Execute();
1202 ICO_WRN("execute failed(%s) err=%d", os_package_name, ret);
1206 sb_app_info = GetAppInfo(sb_package_name);
1207 ret = sb_app_info->Execute();
1209 ICO_WRN("execute failed(%s) err=%d", sb_package_name, ret);
1214 /*--------------------------------------------------------------------------*/
1216 * @brief CicoHomeScreen::Initialize
1219 * @param[in] orientation vertical or horizontal
1220 * @param[in] config config
1221 * @return OK or ERROR
1223 /*--------------------------------------------------------------------------*/
1225 CicoHomeScreen::Initialize(int orientation, CicoGKeyFileConfig *config)
1228 ICO_DBG("CicoHomeScreen::Initialize: start");
1229 /*save instance pointer */
1233 this->config = new CicoGKeyFileConfig();
1234 this->config->Initialize(ICO_HOMESCREEN_CONFIG_FILE);
1236 /*Get application info*/
1237 CreateAppInfoList();
1239 /* get pkg name (home screen,status bar,on screen)*/
1241 ICO_DBG("CicoHomeSceen::Initialize: %s: %s",
1242 getenv("HOME"), getenv("PKG_NAME"));
1243 pkg = getenv("PKG_NAME");
1244 memset(hs_package_name, 0, ICO_HS_MAX_PROCESS_NAME);
1246 strncpy(hs_package_name, pkg, ICO_HS_MAX_PROCESS_NAME);
1249 strncpy(hs_package_name, ICO_HS_PROC_DEFAULT_HOMESCREEN,
1250 ICO_HS_MAX_PROCESS_NAME);
1253 /* Initialize WindowController */
1254 CicoHSWindowController::Initialize();
1255 ICO_DBG("CicoHomeScreen::Initialize: window controller initialized");
1257 ICO_DBG("CicoHomeScreen::Initialize: start connect to systemcontroller");
1258 ico_syc_connect(EventCallBack,NULL);
1259 ICO_DBG("CicoHomeScreen::Initialize: end connect to systemcontroller");
1261 /*initialize system controller*/
1263 ICO_DBG("CicoHomeScreen::Initialize: get package name %s",hs_package_name);
1264 hs_app_info = GetAppInfo(hs_package_name);
1266 /*start home statusbar and onscreen*/
1268 ICO_DBG("CicoHomeScreen::Initialize: start relation apps");
1270 /* Get screen size */
1271 CicoHSWindowController::GetFullScreenSize(orientation,
1272 &full_width,&full_height);
1274 ICO_DBG("full screen size x=%d y=%d",full_width,full_height);
1276 /* MenuScreen Window Size */
1277 menu_width = full_width;
1278 menu_height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
1279 ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1281 /* BackGround Window Size */
1282 bg_width = full_width;
1283 bg_height = full_height;
1285 /* Control Bar Window Size */
1286 ctl_bar_width = full_width;
1287 ctl_bar_height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1289 // load switch display zone config
1290 moveZoneName = config->ConfigGetString("switchzone", "movezone", NULL);
1292 moveZoneAnimation.name = config->ConfigGetString("switchzone",
1294 ICO_HS_ANIMATION_FADE);
1296 moveZoneAnimation.time = config->ConfigGetInteger("switchzone",
1300 ICO_DBG("moveZoneName=%s animation=%s time=%d",
1301 moveZoneName, moveZoneAnimation.name, moveZoneAnimation.time);
1303 ICO_DBG("CicoHomeScreen::Initialize: end");
1308 /*--------------------------------------------------------------------------*/
1310 * @brief CicoHomeScreen::InitializeAppHistory
1311 * Initialize application History Manager
1313 /*--------------------------------------------------------------------------*/
1315 CicoHomeScreen::InitializeAppHistory(void)
1318 if (NULL != m_appHis) {
1322 CicoHSCmdOpts* cmdOpts = CicoHSCmdOpts::getInstance();
1323 m_appHis = new CicoHSAppHistoryExt(cmdOpts->getLoginUser(),
1324 cmdOpts->getHistoryFilePath(),
1325 cmdOpts->getDefaultHistoryFilePath(),
1326 cmdOpts->getFlagPath());
1327 m_appHis->force_flagoff();
1328 m_appHis->setHomeScreen(this);
1331 val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1332 ICO_HS_CONFIG_HSTRY_KEY1,
1333 ICO_HS_CONFIG_HSTRY_DEF1);
1334 ICO_DBG("timer = %s", val);
1335 double dV = atof(val);
1336 m_appHis->setWaitTime(dV);
1338 val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1339 ICO_HS_CONFIG_HSTRY_KEY2,
1340 ICO_HS_CONFIG_HSTRY_DEF2);
1342 if ((NULL != val) && (0 != val) && (0 != strlen(val))) {
1344 split(tmpM, ICO_HS_CONFIG_HSTRY_SPL, vvM);
1346 if (0 != vvM.size()) {
1347 ICO_DBG("manage off = %s split=%d", val, (int)vvM.size());
1348 m_appHis->setFilterManage(vvM);
1350 val = config->ConfigGetString(ICO_HS_CONFIG_HISTORY,
1351 ICO_HS_CONFIG_HSTRY_KEY3,
1352 ICO_HS_CONFIG_HSTRY_DEF3);
1354 if ((NULL != val) && (0 != val) && (0 != strlen(val))) {
1356 split(tmpW, ICO_HS_CONFIG_HSTRY_SPL, vvW);
1358 if (0 != vvW.size()) {
1359 ICO_DBG("write off = %s, split=%d", val, (int)vvW.size());
1360 m_appHis->setFilterWrite(vvW);
1365 /*--------------------------------------------------------------------------*/
1367 * @brief CicoHomeScreen::Finalize
1373 /*--------------------------------------------------------------------------*/
1375 CicoHomeScreen::Finalize(void)
1377 /* Finalize WindowController */
1378 CicoHSWindowController::Finalize();
1380 ico_syc_disconnect();
1385 /*--------------------------------------------------------------------------*/
1387 * @brief CicoHomeScreen::CreateMenuWindow
1388 * create menu window
1393 /*--------------------------------------------------------------------------*/
1395 CicoHomeScreen::CreateMenuWindow(void)
1398 ICO_DBG("CicoHomeScreen::CreateMenuWindow: start");
1399 menu_window = new CicoHSMenuWindow();
1400 menu_window->CreateMenuWindow(ICO_HS_WINDOW_POS_X,ICO_HS_WINDOW_POS_Y,
1401 menu_width,menu_height);
1402 menu_window->ShowWindow();
1403 ICO_DBG("CicoHomeScreen::CreateMenuWindow: end");
1406 /*--------------------------------------------------------------------------*/
1408 * @brief CicoHomeScreen::DeleteMenuWindow
1409 * delete menu window
1414 /*--------------------------------------------------------------------------*/
1416 CicoHomeScreen::DeleteMenuWindow(void)
1418 if (menu_window == NULL) {
1421 menu_window->FreeMenuWindow();
1426 /*--------------------------------------------------------------------------*/
1428 * @brief CicoHomeScreen::UpdateMenuWindow
1429 * update menu window
1434 /*--------------------------------------------------------------------------*/
1436 CicoHomeScreen::UpDateMenuWindow(void)
1442 /*--------------------------------------------------------------------------*/
1444 * @brief CicoHomeScreen::CreateBackWindow
1445 * create back window
1450 /*--------------------------------------------------------------------------*/
1452 CicoHomeScreen::CreateBackWindow(void)
1455 ICO_DBG("CicoHomeScreen::CreateBackWindow");
1456 back_window = new CicoHSBackWindow();
1457 back_window->CreateBackWindow(ICO_HS_WINDOW_POS_X,ICO_HS_WINDOW_POS_Y,
1458 bg_width,bg_height);
1459 back_window->ShowWindow();
1462 /*--------------------------------------------------------------------------*/
1464 * @brief CicoHomeScreen::CreateBackWindow
1465 * create back window
1470 /*--------------------------------------------------------------------------*/
1472 CicoHomeScreen::DeleteBackWindow(void)
1474 if (back_window == NULL) {
1477 back_window->FreeBackWindow();
1481 /*--------------------------------------------------------------------------*/
1483 * @brief CicoHomeScreen::UpDateBackWindow
1484 * update back window
1489 /*--------------------------------------------------------------------------*/
1491 CicoHomeScreen::UpDateBackWindow(void)
1497 /*--------------------------------------------------------------------------*/
1499 * @brief CicoHomeScreen::CreateControlBarWindow
1500 * create control bar window
1505 /*--------------------------------------------------------------------------*/
1507 CicoHomeScreen::CreateControlBarWindow(void)
1510 ICO_DBG("CicoHomeScreen::CreateControlBarWindow");
1511 ctl_bar_window = new CicoHSControlBarWindow();
1512 ctl_bar_window->CreateControlBarWindow(ICO_HS_MENU_WINDOW_POS_X,bg_height -
1513 ctl_bar_height,ctl_bar_width,
1515 ctl_bar_window->ShowWindow();
1518 /*--------------------------------------------------------------------------*/
1520 * @brief CicoHomeScreen::DeleteControlBarWindow
1521 * delete control bar window
1526 /*--------------------------------------------------------------------------*/
1528 CicoHomeScreen::DeleteControlBarWindow(void)
1530 if (ctl_bar_window == NULL) {
1533 ctl_bar_window->FreeControlBarWindow();
1534 delete ctl_bar_window;
1537 /*--------------------------------------------------------------------------*/
1539 * @brief CicoHomeScreen::CreateSwipeInputWindow
1540 * create swipe input windows
1545 /*--------------------------------------------------------------------------*/
1547 CicoHomeScreen::CreateSwipeInputWindow(void)
1549 int pos_y, swipe_height;
1551 ICO_DBG("CicoHomeScreen::CreateSwipeInputWindow: start");
1552 /* cullentry SwipeInput windows is fixed size */
1553 pos_y = ICO_HS_WINDOW_POS_Y + ICO_HS_SWIPE_TOUCH_DISTANCE_TOP;
1554 swipe_height = full_height - pos_y - ICO_HS_SWIPE_TOUCH_DISTANCE_BOTTOM;
1556 /* left side window */
1557 swipe_input_windows[0] = new CicoHSSwipeInputWindow();
1558 swipe_input_windows[0]->
1559 CreateSwipeInputWindow(ICO_HS_WINDOW_POS_X, pos_y,
1560 ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, swipe_height,
1562 swipe_input_windows[0]->ShowWindow();
1564 /* right side window */
1565 swipe_input_windows[1] = new CicoHSSwipeInputWindow();
1566 swipe_input_windows[1]->
1567 CreateSwipeInputWindow(full_width - ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, pos_y,
1568 ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, swipe_height,
1570 swipe_input_windows[1]->ShowWindow();
1572 #if 0 /* currently not support(not fix specification) */
1573 /* buttom side window */
1574 swipe_input_windows[2] = new CicoHSSwipeInputWindow();
1575 swipe_input_windows[2]->
1576 CreateSwipeInputWindow(ICO_HS_WINDOW_POS_X,
1577 full_height - ICO_HS_SWIPE_TOUCH_SWIPE_HEIGHT,
1578 full_width, ICO_HS_SWIPE_TOUCH_SWIPE_WIDTH, "buttom");
1580 swipe_input_windows[2]->ShowWindow();
1581 num_swipe_input_windows = 3;
1583 num_swipe_input_windows = 2;
1585 ICO_DBG("CicoHomeScreen::CreateSwipeInputWindow: end");
1588 /*--------------------------------------------------------------------------*/
1590 * @brief CicoHomeScreen::DeleteSwipeInputWindow
1591 * delete swipe input windows
1596 /*--------------------------------------------------------------------------*/
1598 CicoHomeScreen::DeleteSwipeInputWindow(void)
1602 for (idx = 0; idx < num_swipe_input_windows; idx++) {
1603 if (swipe_input_windows[idx]) {
1604 swipe_input_windows[idx]->FreeSwipeInputWindow();
1605 delete swipe_input_windows[idx];
1606 swipe_input_windows[idx] = NULL;
1609 num_swipe_input_windows = 0;
1612 /*--------------------------------------------------------------------------*/
1614 * @brief launch applications
1616 * @param filepath start applications list file path
1617 * @param filepathD defalt start applications list file path
1619 * @retval true success
1620 * @retval false fail
1622 /*--------------------------------------------------------------------------*/
1623 static Eina_Bool launchApps(void* data)
1626 launcApps_data_t* x = (launcApps_data_t*) data;
1627 if ((NULL == x) || (NULL == x->hs)) {
1628 ICO_DBG("end fail");
1629 return ECORE_CALLBACK_CANCEL;
1632 vector<pairAppidSubd> apps;
1633 x->hs->readStartupApp(apps);
1635 int sz = apps.size();
1636 for (int i =sz; i > 0; i--) {
1637 string appid = apps[i-1].first;
1638 bool bFLAG = apps[i-1].second;
1639 const char* app = appid.c_str();
1640 ICO_PRF("CHG_APP_STA 1.request app=%s", app);
1641 int pid = aul_launch_app(appid.c_str(), NULL);
1642 ICO_DBG(" 1.request [%d]%d:%s:%d", i, pid, app, (int)bFLAG);
1643 if ((0 < pid) && (NULL != x->hs)) {
1644 x->hs->startupCheckAdd(pid, appid, bFLAG);
1647 ICO_DBG("end success");
1648 return ECORE_CALLBACK_CANCEL;
1651 /*--------------------------------------------------------------------------*/
1653 * @brief CicoHomeScreen::StartHomeScreen
1659 /*--------------------------------------------------------------------------*/
1661 CicoHomeScreen::StartHomeScreen(int orientation)
1665 ICO_TRA("CicoHomeScreen::StartHomeScreen Enter");
1667 /*save instance pointer */
1671 this->config = new CicoGKeyFileConfig();
1672 this->config->Initialize(ICO_HOMESCREEN_CONFIG_FILE);
1674 /* init home screen soud */
1675 CicoSound::GetInstance()->Initialize(this->config);
1677 /*Get application info*/
1678 CreateAppInfoList();
1680 /* get pkg name (home screen,status bar,on screen)*/
1682 ICO_DBG("CicoHomeSceen::StartHomeScreen: %s: %s",
1683 getenv("HOME"), getenv("PKG_NAME"));
1684 pkg = getenv("PKG_NAME");
1685 memset(hs_package_name, 0, ICO_HS_MAX_PROCESS_NAME);
1687 strncpy(hs_package_name, pkg, ICO_HS_MAX_PROCESS_NAME);
1690 strncpy(hs_package_name, ICO_HS_PROC_DEFAULT_HOMESCREEN,
1691 ICO_HS_MAX_PROCESS_NAME);
1694 /* create application control instance */
1695 CicoHSAppControl *m_appctrl = CicoHSAppControl::getInstance();
1697 /* create server instance */
1698 CicoHSServer *server = CicoHSServer::getInstance();
1699 server->setAppCtrl(m_appctrl);
1700 server->startup(10001, "ico_hs_protocol");
1702 /* Initialize WindowController */
1703 CicoHSWindowController::Initialize();
1704 ICO_DBG("CicoHomeScreen::StartHomeScreen: window controller initialized");
1706 ICO_DBG("CicoHomeScreen::StartHomeScreen: start connect to systemcontroller");
1707 ico_syc_connect(EventCallBack,NULL);
1708 for (retry = 0; retry < (2000/10); retry++) {
1710 if (ico_syc_isconnect()) break;
1713 ICO_DBG("CicoHomeScreen::StartHomeScreen: end connect to systemcontroller");
1715 /*initialize system controller*/
1717 ICO_DBG("CicoHomeScreen::StartHomeScreen: get package name %s",hs_package_name);
1718 hs_app_info = GetAppInfo(hs_package_name);
1720 /*start home statusbar and onscreen*/
1722 ICO_DBG("CicoHomeScreen::StartHomeScreen: start relation apps");
1724 /* Get screen size */
1725 CicoHSWindowController::GetFullScreenSize(orientation,
1726 &full_width,&full_height);
1728 ICO_DBG("full screen size x=%d y=%d",full_width,full_height);
1730 /* MenuScreen Window Size */
1731 menu_width = full_width;
1732 menu_height = full_height - ICO_HS_STATUSBAR_WINDOW_HEIGHT -
1733 ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1735 /* BackGround Window Size */
1736 bg_width = full_width;
1737 bg_height = full_height;
1739 /* Control Bar Window Size */
1740 ctl_bar_width = full_width;
1741 ctl_bar_height = ICO_HS_CONTROLBAR_WINDOW_HEIGHT;
1743 // load switch display zone config
1744 moveZoneName = config->ConfigGetString("switchzone", "movezone", NULL);
1746 moveZoneAnimation.name = config->ConfigGetString("switchzone",
1748 ICO_HS_ANIMATION_FADE);
1749 moveZoneAnimation.time = config->ConfigGetInteger("switchzone",
1752 ICO_DBG("moveZoneName=%s animation=%s time=%d",
1753 moveZoneName, moveZoneAnimation.name, moveZoneAnimation.time);
1755 // AUL Listen Signal set(launch/dead)
1756 initAulListenXSignal();
1758 // application history class init. before call launchApps
1759 InitializeAppHistory();
1761 /* application history launch */
1762 t_launcApps_data* x = new t_launcApps_data;
1763 CicoHSCmdOpts* cmdOpts = CicoHSCmdOpts::getInstance();
1764 x->filePath = cmdOpts->getHistoryFilePath();
1765 x->filePathD = cmdOpts->getDefaultHistoryFilePath();
1767 ecore_timer_add(0.01, launchApps, x);
1769 /* Create BackGround window */
1772 /* Create SwipeInput window */
1773 CicoHSSwipeTouch::Initialize(hs_instance->ctl_bar_window, hs_instance->m_appHis,
1774 full_width, full_height);
1775 CreateSwipeInputWindow();
1777 /* Create ControlBar window */
1778 CreateControlBarWindow();
1780 /* Create Menu window */
1783 /*Show Home Screen*/
1784 ShowHomeScreenLayer();
1786 ICO_TRA("CicoHomeScreen::StartHomeScreen Leave");
1790 /*--------------------------------------------------------------------------*/
1792 * @brief CicoHomeScreen::GetMode
1795 * @param[in] mode status
1798 /*--------------------------------------------------------------------------*/
1800 CicoHomeScreen::GetMode(void)
1805 /*--------------------------------------------------------------------------*/
1807 * @brief CicoHomeScreen::SetMode
1810 * @param[in] mode status
1813 /*--------------------------------------------------------------------------*/
1815 CicoHomeScreen::SetMode(int mode)
1820 /*--------------------------------------------------------------------------*/
1822 * @brief CicoHomeScreen::ChangeMode
1828 /*--------------------------------------------------------------------------*/
1830 CicoHomeScreen::ChangeMode(int pattern)
1834 if (hs_instance->menu_window == NULL) {
1838 if (hs_instance->GetMode() == ICO_HS_MODE_MENU) {
1839 ico_syc_animation_t animation;
1840 ICO_DBG("CicoHomeScreen::ChangeMode: MENU->APP");
1841 if (pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE) {
1842 animation.name = ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1845 animation.name = ICO_HS_MENU_HIDE_ANIMATION_FADE;
1847 animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1848 hs_instance->menu_window->Hide(&animation);
1849 for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++) {
1850 hs_instance->swipe_input_windows[idx]->Show();
1852 hs_instance->SetMode(ICO_HS_MODE_APPLICATION);
1853 CicoHSAppInfo *appinfo = hs_instance->GetActiveAppInfo();
1854 if (NULL != appinfo) {
1855 ico_syc_change_active(appinfo->GetAppId(), appinfo->GetLastSurface());
1858 else if (hs_instance->GetMode() ==ICO_HS_MODE_APPLICATION) {
1859 ico_syc_animation_t animation;
1860 ICO_DBG("CicoHomeScreen::ChangeMode: APP->MENU");
1861 if (pattern == ICO_HS_SHOW_HIDE_PATTERN_SLIDE) {
1862 animation.name = ICO_HS_MENU_SHOW_ANIMATION_SLIDE;
1865 animation.name = ICO_HS_MENU_SHOW_ANIMATION_FADE;
1867 animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1868 hs_instance->menu_window->Show(&animation);
1869 for (idx = 0; idx < hs_instance->num_swipe_input_windows; idx++) {
1870 hs_instance->swipe_input_windows[idx]->Hide();
1872 hs_instance->SetMode(ICO_HS_MODE_MENU);
1876 /*--------------------------------------------------------------------------*/
1878 * @brief CicoHomeScreen::ExecuteApp
1879 * execute application
1884 /*--------------------------------------------------------------------------*/
1886 CicoHomeScreen::ExecuteApp(const char*appid)
1888 hs_instance->ExecuteApp_i(appid);
1891 /*--------------------------------------------------------------------------*/
1893 * @brief CicoHomeScreen::TerminateApp
1894 * teminate application
1899 /*--------------------------------------------------------------------------*/
1901 CicoHomeScreen::TerminateApp(const char*appid)
1903 hs_instance->TerminateApp_i(appid);
1906 /*--------------------------------------------------------------------------*/
1908 * @brief CicoHomeScreen::setActiveApp
1909 * active(touch operate app) notice
1914 /*--------------------------------------------------------------------------*/
1916 CicoHomeScreen::setActiveApp(const char* appid)
1918 if ((NULL == appid) || (0 == appid) || (0 == strlen(appid))) {
1921 if (NULL != m_appHis) {
1922 m_appHis->activeApp(appid);
1926 /*--------------------------------------------------------------------------*/
1928 * @brief CicoHomeScreen::SetNightMode
1929 * set night mode theme
1931 * @param[in] data user data
1933 /*--------------------------------------------------------------------------*/
1935 CicoHomeScreen::SetNightMode(void* data)
1937 ICO_TRA("CicoHomeScreen::SetNightMode Enter");
1938 // night mode action
1939 hs_instance->ctl_bar_window->SetNightMode();
1940 hs_instance->menu_window->SetNightMode();
1941 ICO_TRA("CicoHomeScreen::SetNightMode Leave");
1944 /*--------------------------------------------------------------------------*/
1946 * @brief CicoHomeScreen::SetRegulation
1947 * regulation action and set regualtion theme
1949 * @param[in] data user data
1951 /*--------------------------------------------------------------------------*/
1953 CicoHomeScreen::SetRegulation(void* data)
1955 ICO_TRA("CicoHomeScreen::SetRegulation Enter");
1957 hs_instance->controlRegulation();
1958 // regulation action
1959 hs_instance->ctl_bar_window->SetRegulation();
1960 ico_syc_animation_t animation;
1961 animation.name = ICO_HS_MENU_HIDE_ANIMATION_SLIDE;
1962 animation.time = ICO_HS_MENU_ANIMATION_DURATION;
1963 hs_instance->menu_window->Hide(&animation);
1965 // force focus change
1966 if (false == CicoHSSystemState::getInstance()->getRegulation()) {
1967 CicoHSAppInfo *active_appinfo = hs_instance->GetActiveAppInfo();
1968 if (NULL != active_appinfo) {
1969 ico_syc_change_active(active_appinfo->GetAppId(),
1970 active_appinfo->GetLastSurface());
1971 ico_syc_change_active(active_appinfo->GetAppId(), 0);
1975 if (NULL != hs_instance->ctl_bar_window) {
1976 const char *ctl_bar_appid = hs_instance->ctl_bar_window->GetAppId();
1977 int ctl_bar_surface = hs_instance->ctl_bar_window->GetSurfaceId();
1978 ico_syc_change_active(ctl_bar_appid, ctl_bar_surface);
1979 ico_syc_change_active(ctl_bar_appid, 0);
1983 ICO_TRA("CicoHomeScreen::SetRegulation Leave");
1986 /*--------------------------------------------------------------------------*/
1988 * @brief CicoHomeScreen::RenewAppInfoList_i
1989 * renewal application info list
1994 /*--------------------------------------------------------------------------*/
1996 CicoHomeScreen::RenewAppInfoList_i(void)
2000 CicoHSAppInfo *tmp_apps_info[ICO_HS_MAX_APP_NUM];
2001 int tmp_application_num = 0;
2002 const char *appid_p = 0;
2004 for(ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++){
2005 tmp_apps_info[ii] = NULL;
2008 /* get APP information*/
2009 std::vector<CicoAilItems> aillist = life_cycle_controller->getAilList();
2013 (ii < (int)aillist.size()) && (ii < ICO_HS_MAX_APP_NUM);
2015 ICO_DBG("aillist[%d].m_appid.c_str() = %s",
2016 ii, aillist[ii].m_appid.c_str());
2018 for (kk = 0; kk < ICO_HS_MAX_APP_NUM; kk++) {
2019 if (apps_info[kk] == NULL) {
2023 if (strcmp(aillist[ii].m_appid.c_str(),
2024 apps_info[kk]->GetAppId()) == 0) {
2026 tmp_apps_info[ii] = apps_info[kk];
2027 ICO_DBG("shift aillist[%d].m_appid.c_str() = %s",
2028 ii, aillist[ii].m_appid.c_str());
2032 if (kk == ICO_HS_MAX_APP_NUM) {
2033 tmp_apps_info[ii] = new CicoHSAppInfo(aillist[ii].m_appid.c_str());
2034 ICO_DBG("create aillist[%d].m_appid.c_str() = %s",
2035 ii, aillist[ii].m_appid.c_str());
2037 tmp_application_num++;
2040 /* delete instance */
2041 for (ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
2042 if (apps_info[ii] == NULL) {
2045 appid_p = apps_info[ii]->GetAppId();
2046 for ( kk = 0; kk < tmp_application_num; kk++) {
2047 if (strcmp(appid_p, tmp_apps_info[kk]->GetAppId()) == 0) {
2051 if (kk == tmp_application_num) {
2052 delete apps_info[ii];
2053 ICO_DBG("delete apps_info[%d]->GetAppId() = %s",
2059 for ( ii = 0; ii < ICO_HS_MAX_APP_NUM; ii++) {
2060 apps_info[ii] = tmp_apps_info[ii];
2063 application_num = tmp_application_num;
2066 /*--------------------------------------------------------------------------*/
2068 * @brief CicoHomeScreen::RenewAppInfoList
2069 * renewal appinfolist
2074 /*--------------------------------------------------------------------------*/
2076 CicoHomeScreen::RenewAppInfoList(void)
2078 ICO_TRA("CicoHomeScreen::RenewAppInfoList Enter");
2079 hs_instance->RenewAppInfoList_i();
2080 ICO_TRA("CicoHomeScreen::RenewAppInfoList Leave");
2083 /*--------------------------------------------------------------------------*/
2085 * @brief CicoHomeScreen::startupCheckAdd
2086 * start-up application infomation add
2092 /*--------------------------------------------------------------------------*/
2093 void CicoHomeScreen::startupCheckAdd(int pid, const std::string& appid,
2096 if (NULL != m_appHis) {
2097 m_appHis->startupCheckAdd(pid, appid, bSubDisp);
2101 /*--------------------------------------------------------------------------*/
2103 * @brief CicoHomeScreen::startupCheck
2104 * start-up application check
2106 * @param[in] appid check target
2108 /*--------------------------------------------------------------------------*/
2109 void CicoHomeScreen::startupCheck(const char* appid)
2111 ICO_TRA("CicoHomeScreen::startupCheck Enter");
2112 if (NULL == life_cycle_controller) {
2113 ICO_ERR("life_cycle_controller is null");
2114 ICO_TRA("CicoHomeScreen::startupCheck Leave");
2117 if (NULL == m_appHis) {
2118 ICO_ERR("m_appHis is null");
2119 ICO_TRA("CicoHomeScreen::startupCheck Leave");
2122 if (false == m_appHis->isStartupChecking()) {
2123 ICO_TRA("CicoHomeScreen::startupCheck Leave");
2126 m_appHis->update_appid();
2127 m_appHis->startupEntryFinish(appid);
2128 if (false == m_appHis->isFinish()) {
2129 ICO_TRA("CicoHomeScreen::startupCheck Leave");
2133 ICO_TRA("CicoHomeScreen::startupCheck Leave");
2136 /*--------------------------------------------------------------------------*/
2138 * @brief CicoHomeScreen::finishStartup
2139 * start-up application check
2141 * @param[in] appid check target
2143 /*--------------------------------------------------------------------------*/
2145 void CicoHomeScreen::finishStartup(void)
2147 ICO_TRA("CicoHomeScreen::finishStartup Enter");
2149 string last = m_appHis->getLastStartupAppid();
2150 const string& subDisp = m_appHis->getSubDispAppid();
2152 list<string> h = m_appHis->getAppHistory();
2153 // last appid is empty then get new last appid
2154 if (true == last.empty()) {
2155 list<string>::iterator it_h = h.begin();
2156 while (it_h != h.end()) {
2157 if (0 != subDisp.compare(*it_h)) {
2164 list<string>::reverse_iterator rit_h = h.rbegin();
2165 while(rit_h != h.rend()) {
2166 CicoHSAppInfo *ai = GetAppInfo((*rit_h).c_str());
2171 ICO_DBG("Raise %s", (*rit_h).c_str());
2173 const char* appid = ai->GetAppId();
2174 int surface = ai->GetLastSurface();
2175 if ((0 != last.compare(appid)) && (0 != subDisp.compare(appid))) {
2176 ico_syc_show(appid, surface, NULL);
2177 ico_syc_hide(appid, surface, NULL);
2183 CicoHSAppInfo *ai = GetAppInfo(subDisp.c_str());
2185 requestChangeZone(ai);
2188 ai = GetAppInfo(last.c_str());
2190 const char* appid = ai->GetAppId();
2191 int surface = ai->GetLastSurface();
2192 ico_syc_show(appid, surface, NULL);
2193 ico_syc_change_active(appid, surface);
2194 hs_instance->SetActiveAppInfo(appid);
2197 m_appHis->stopStartupCheck();
2198 ICO_TRA("CicoHomeScreen::finishStartup Leave");
2201 /*--------------------------------------------------------------------------*/
2203 * @brief CicoHomeScreen::readStartupApp
2204 * read start-up application data
2206 * @param[in] appid check target
2208 /*--------------------------------------------------------------------------*/
2209 void CicoHomeScreen::readStartupApp(std::vector<pairAppidSubd>& apps)
2211 ICO_TRA("CicoHomeScreen::readStartupApp Enter");
2212 if (NULL == m_appHis) {
2216 m_appHis->readAppHistory(apps);
2218 ICO_TRA("CicoHomeScreen::readStartupApp Leave(%d)", (int)apps.size());
2222 /*--------------------------------------------------------------------------*/
2224 * @brief CicoHomeScreen::requestHideAppid
2225 * request Hide appid
2229 /*--------------------------------------------------------------------------*/
2230 void CicoHomeScreen::requestHideAppid(const std::string& app)
2232 const char* appid = app.c_str();
2233 ICO_TRA("start %s", appid);
2234 CicoHSAppInfo *ai = GetAppInfo(appid);
2236 ICO_DBG("end %d", appid);
2239 int surface = ai->GetLastSurface();
2240 ico_syc_hide(appid, surface, NULL);
2244 /*--------------------------------------------------------------------------*/
2246 * @brief CicoHomeScreen::requestShowAppid
2247 * request Show appid
2251 /*--------------------------------------------------------------------------*/
2252 void CicoHomeScreen::requestShowAppid(const std::string& app)
2254 const char* appid = app.c_str();
2255 ICO_TRA("start %s", appid);
2256 CicoHSAppInfo *ai = GetAppInfo(appid);
2258 ICO_DBG("end %d", appid);
2261 int surface = ai->GetLastSurface();
2262 ico_syc_show(appid, surface, NULL);
2266 /*--------------------------------------------------------------------------*/
2268 * @brief CicoHomeScreen::requestActivationAppid
2269 * request Activation
2273 /*--------------------------------------------------------------------------*/
2274 void CicoHomeScreen::requestActivationAppid(const std::string& app)
2276 const char* appid = app.c_str();
2277 ICO_TRA("CicoHomeScreen::requestActivationAppid Enter(%s)", appid);
2278 CicoHSAppInfo *ai = GetAppInfo(appid);
2280 ICO_DBG("end %d", appid);
2283 int surface = ai->GetLastSurface();
2284 hs_instance->SetActiveAppInfo(app.c_str());
2285 ico_syc_show(appid, surface, NULL);
2286 ico_syc_change_active(appid, surface);
2287 ICO_TRA("CicoHomeScreen::requestActivationAppid Leave");
2290 /*--------------------------------------------------------------------------*/
2292 * @brief CicoHomeScreen::controlRegulation
2295 * @param reqStt true / false
2297 /*--------------------------------------------------------------------------*/
2298 void CicoHomeScreen::controlRegulation(bool regStt)
2300 ICO_TRA("CicoHomeScreen::controlRegulation Enter(%s)",
2301 regStt? "true": "false");
2302 if (NULL == m_appHis) {
2303 ICO_ERR("m_appHis is null");
2304 ICO_TRA("CicoHomeScreen::controlRegulation Leave");
2307 const string& wapp = m_appHis->getSelectApp(); // select appid get
2308 if (false == wapp.empty()) { // select appid nothing
2309 const string& napp = m_appHis->getNearHistory(); // history top appid get
2310 if (0 != wapp.compare(napp)) { // history top, wait app is Eqale
2311 requestHideAppid(napp);
2312 requestActivationAppid(wapp);
2313 m_appHis->moveHistoryHead(wapp);
2315 m_appHis->clearSelectApp(); // select appid clear
2316 m_appHis->homeSwipe();
2318 ICO_TRA("CicoHomeScreen::controlRegulation Leave");
2321 /*--------------------------------------------------------------------------*/
2323 * @brief CicoHomeScreen::ActivationUpdate
2324 * history update by swipe app
2327 * @retval true history update
2328 * @retval false no history updath
2330 /*--------------------------------------------------------------------------*/
2332 CicoHomeScreen::ActivationUpdate(void)
2334 return hs_instance->ActivationUpdate_i();
2337 /*--------------------------------------------------------------------------*/
2339 * @brief CicoHomeScreen::ActivationUpdate_i
2340 * history update by swipe app
2343 * @retval true history update
2344 * @retval false no history updath
2346 /*--------------------------------------------------------------------------*/
2348 CicoHomeScreen::ActivationUpdate_i(void)
2350 ICO_TRA("CicoHomeScreen::ActivationUpdate_i Enter");
2351 if (NULL == m_appHis) {
2352 ICO_ERR("m_appHis is null");
2353 ICO_TRA("CicoHomeScreen::ActivationUpdate_i Leave(false)");
2357 const string& wapp = m_appHis->getSelectApp(); // select appid get
2358 if (false == wapp.empty()) { // select appid nothing
2359 const string& napp = m_appHis->getNearHistory(); // history top appid get
2360 if (0 != wapp.compare(napp)) { // history top, wait app is Eqale
2361 requestActivationAppid(wapp);
2362 m_appHis->moveHistoryHead(wapp);
2365 m_appHis->clearSelectApp(); // select appid clear
2366 m_appHis->homeSwipe();
2368 ICO_TRA("CicoHomeScreen::ActivationUpdate_i Leave(%s)",
2369 bR? "true": "false");
2373 /*--------------------------------------------------------------------------*/
2375 * @brief CicoHomeScreen::ShowApp_i
2380 /*--------------------------------------------------------------------------*/
2382 CicoHomeScreen::ShowApp_i(const std::string& app)
2384 CicoHSAppInfo *appinfo = GetAppInfo(app.c_str());
2385 if (appinfo == NULL) {
2386 ICO_TRA("end get appinfo is NULL");
2390 ico_syc_animation_t animation;
2391 animation.name = ICO_HS_MENU_HIDE_ANIMATION_FADE;
2392 animation.time = ICO_HS_MENU_ANIMATION_DURATION;
2394 ico_syc_show(appinfo->GetAppId(), appinfo->GetLastSurface(), &animation);
2395 ico_syc_change_active(appinfo->GetAppId(), appinfo->GetLastSurface());
2396 hs_instance->SetActiveAppInfo(appinfo->GetAppId());
2398 // RaiseApplicationWindow(appinfo->GetAppId(),
2399 // appinfo->GetLastSurface());
2400 ICO_DBG("raise app %s", app.c_str());
2401 m_appHis->moveHistoryHead(app);
2404 /*--------------------------------------------------------------------------*/
2406 * @brief CicoHomeScreen::ShowApp
2411 /*--------------------------------------------------------------------------*/
2413 CicoHomeScreen::ShowApp(const std::string& app)
2415 hs_instance->ShowApp_i(app);
2418 /*--------------------------------------------------------------------------*/
2420 * @brief CicoHomeScreen::HideAppid
2425 /*--------------------------------------------------------------------------*/
2427 CicoHomeScreen::HideApp(const std::string& app)
2429 const char* appid = app.c_str();
2430 ICO_TRA("start %s", appid);
2431 CicoHSAppInfo *ai = GetAppInfo(appid);
2433 ICO_DBG("end %d", appid);
2437 ico_syc_animation_t animation;
2438 animation.name = ICO_HS_MENU_HIDE_ANIMATION_FADE;
2439 animation.time = ICO_HS_MENU_ANIMATION_DURATION;
2441 int surface = ai->GetLastSurface();
2442 ico_syc_hide(appid, surface, &animation);
2446 /*--------------------------------------------------------------------------*/
2448 * @brief CicoHomeScreen::MoveApp
2454 /*--------------------------------------------------------------------------*/
2456 CicoHomeScreen::MoveApp(const std::string& app, const std::string& zone)
2458 CicoHSAppInfo *appinfo = GetAppInfo(app.c_str());
2459 if ((CicoHSAppInfo*)0 == appinfo) {
2460 ICO_DBG("GetAppInfo(%s) is NULL" , app.c_str());
2464 int surface = appinfo->GetLastSurface();
2465 ico_hs_window_info* wininfo = appinfo->GetWindowInfobySurface(surface);
2467 int layer = HS_LAYER_APPLICATION;
2468 const char *dispzone = zone.c_str();
2469 ico_syc_win_move_t move;
2470 move.zone = dispzone;
2477 ico_syc_move(wininfo->appid, wininfo->surface, &move,
2478 &hs_instance->moveZoneAnimation);
2481 // vim: set expandtab ts=4 sw=4: