X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fhomescreen.cpp;h=403fdf2de9ae94edb787fa6a1967f2f8ffbb54ce;hb=b20509dec7cca94ca4e6bd87f6d6f27320983d19;hp=b518139050889b21a12920289fa3056fc0f54f68;hpb=d58138e0ceb19b3f201ec5e6e7126015db2cfead;p=apps%2Fagl-service-homescreen.git diff --git a/src/homescreen.cpp b/src/homescreen.cpp index b518139..403fdf2 100644 --- a/src/homescreen.cpp +++ b/src/homescreen.cpp @@ -17,19 +17,285 @@ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif +#include #include #include +#include +#include +#include #include "hs-helper.h" -#include "hmi-debug.h" #include "hs-clientmanager.h" +#include "hs-appinfo.h" +#include "hs-config.h" +#include "hs-apprecover.h" + const char _error[] = "error"; -const char _application_name[] = "application_name"; +const char _application_id[] = "application_id"; const char _display_message[] = "display_message"; const char _reply_message[] = "reply_message"; +const char _keyData[] = "data"; +const char _keyId[] = "id"; +const char _parameter[] = "parameter"; +const char _area[] = "area"; + +struct hs_handshake { + hs_handshake(int times, int sleep) : m_times(times), m_sleep(sleep) {} + int start(afb_api_t api); + void handshake_loop(afb_api_t api, int times, int sleeps); + + enum HandshakeStatus { + Handshake_Idle = 0, + Handshake_Subscribing, + Handshake_Subscribe_Fail, + Handshake_WaitEvent, + Handshake_Over + }; + static int hs_sts; + +private: + const std::string sub_event = "windowmanager/handshake"; + const int m_times; + const int m_sleep; +}; + +int hs_handshake::hs_sts = hs_handshake::Handshake_Idle; + +/** + * handshake callback function + * + * #### Parameters + * - obj : reply json object + * - error : api_call error + * - info : api_call information + * + * #### Return + * None + * + */ +void handshake_subscribe_callback(struct json_object *obj, const char *error, const char *info) +{ + AFB_NOTICE("subscribe handshake reply: obj=%s, error=%s, info=%s", json_object_to_json_string(obj), error, info); + if(hs_handshake::hs_sts == hs_handshake::Handshake_Over) { + return; + } + if(error == nullptr) { + hs_handshake::hs_sts = hs_handshake::Handshake_WaitEvent; + } + else { + hs_handshake::hs_sts = hs_handshake::Handshake_Subscribe_Fail; + } +} + +/** + * handshake event function + * + * #### Parameters + * - api : the api + * - event : received event name + * - object : received json object + * + * #### Return + * 0 : event can transfer to others + * 1 : event not transfer to others + */ +int on_handshake_event(afb_api_t api, const char *event, struct json_object *object) +{ + AFB_NOTICE("received handshake event from windowmanager."); + hs_handshake::hs_sts = hs_handshake::Handshake_Over; + return 1; +} + +/** + * start handshake function + * + * #### Parameters + * - api : the api + * + * #### Return + * 0 : handshake success + * other : handshake fail + * + */ +int hs_handshake::start(afb_api_t api) +{ + AFB_NOTICE("start handshake with windowmanager."); + setEventHook(sub_event.c_str(), on_handshake_event); + + std::thread th(&hs_handshake::handshake_loop, this, api, m_times, m_sleep); + th.detach(); + return 0; +} + +/** + * handshake loop + * + * #### Parameters + * - api : the api + * + * #### Return + * None + * + */ +void hs_handshake::handshake_loop(afb_api_t api, int times, int sleeps) +{ + int count = 0; + do { + // try to subscribe handshake event + if(hs_handshake::hs_sts == hs_handshake::Handshake_Idle + || hs_handshake::hs_sts == hs_handshake::Handshake_Subscribe_Fail) { + hs_handshake::hs_sts = Handshake_Subscribing; + HS_WmProxy wm_proxy; + wm_proxy.subscribe(api, HS_WmProxy::Event_Handshake, handshake_subscribe_callback); + } + + // wait handshake event + if(hs_handshake::hs_sts == hs_handshake::Handshake_Over) { + break; + } + + ++count; + usleep(sleeps*1000); + } while(count < times); + AFB_NOTICE("handshake over, m_times=%d, m_sleep=%d, count=%d.", times, sleeps, count); + HS_AppRecover::instance()->startRecovery(api); +} + +struct hs_instance { + HS_ClientManager *client_manager; // the connection session manager + HS_AppInfo *app_info; // application info + HS_AppRecover *app_recover; + + hs_instance() : client_manager(HS_ClientManager::instance()), app_info(HS_AppInfo::instance()), app_recover(HS_AppRecover::instance()) {} + int init(afb_api_t api); + void setEventHook(const char *event, const event_hook_func f); + void onEvent(afb_api_t api, const char *event, struct json_object *object); +private: + std::unordered_map> event_hook_list; +}; + +static struct hs_instance *g_hs_instance; + +/** + * init function + * + * #### Parameters + * - api : the api serving the request + * + * #### Return + * 0 : init success + * 1 : init fail + * + */ +int hs_instance::init(afb_api_t api) +{ + if(client_manager == nullptr) { + AFB_ERROR("client_manager is nullptr."); + return -1; + } + client_manager->init(); -static HS_ClientManager* g_client_manager = HS_ClientManager::instance(); + if(app_info == nullptr) { + AFB_ERROR("app_info is nullptr."); + return -1; + } + app_info->init(api); + + HS_Config hs_config; + if(hs_config.readConfig() < 0) { + AFB_ERROR("read config file failed."); + return -1; + } + + if(app_recover == nullptr) { + AFB_ERROR("app_recover is nullptr."); + return -1; + } + app_recover->init(api); + app_recover->setRecoverMap(hs_config.getRecoverMap()); + + const struct handshake_info *h = hs_config.getHandshakeInfo(); + struct hs_handshake handshake(h->times, h->sleep); + if(handshake.start(api) < 0) { + AFB_ERROR("handshake with windowmanager failed."); + return -1; + } + + return 0; +} + +/** + * set event hook + * + * #### Parameters + * - event : event name + * - f : hook function + * + * #### Return + * Nothing + */ +void hs_instance::setEventHook(const char *event, const event_hook_func f) +{ + if(event == nullptr || f == nullptr) { + AFB_WARNING("argument is null."); + return; + } + + std::string ev(event); + auto it = event_hook_list.find(ev); + if(it != event_hook_list.end()) { + it->second.push_back(f); + } + else { + std::list l; + l.push_back(f); + event_hook_list[ev] = std::move(l); + } +} + +/** + * onEvent function + * + * #### Parameters + * - api : the api serving the request + * - event : event name + * - object : event json object + * + * #### Return + * Nothing + */ +void hs_instance::onEvent(afb_api_t api, const char *event, struct json_object *object) +{ + std::string ev(event); + auto it = event_hook_list.find(ev); + if(it != event_hook_list.end()) { + for(auto &ref : it->second) { + if(ref(api, event, object)) + break; + } + } +} + +/** + * set event hook + * + * #### Parameters + * - event : event name + * - f : hook function pointer + * + * #### Return + * Nothing + */ +void setEventHook(const char *event, const event_hook_func f) +{ + if(g_hs_instance == nullptr) { + AFB_ERROR("g_hs_instance is null."); + return; + } + + g_hs_instance->setEventHook(event, f); +} /* ********** Method of HomeScreen Service (API) ********** @@ -39,7 +305,7 @@ static void pingSample(afb_req_t request) { static int pingcount = 0; afb_req_success_f(request, json_object_new_int(pingcount), "Ping count = %d", pingcount); - HMI_NOTICE("homescreen-service","Verbosity macro at level notice invoked at ping invocation count = %d", pingcount); + AFB_DEBUG("Verbosity macro at level notice invoked at ping invocation count = %d", pingcount); pingcount++; } @@ -49,7 +315,7 @@ static void pingSample(afb_req_t request) * * #### Parameters * Request key - * - application_name : application name + * - application_id : application id * * #### Return * None @@ -57,18 +323,37 @@ static void pingSample(afb_req_t request) */ static void tap_shortcut (afb_req_t request) { - HMI_NOTICE("homescreen-service","called."); - int ret = g_client_manager->tap_shortcut(request); - if (ret != 0) { - afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); - return; + AFB_DEBUG("called."); + int ret = 0; + struct json_object *param_obj, *area_obj; + const char* value = afb_req_value(request, _application_id); + if (value + && json_object_object_get_ex(afb_req_json(request), _parameter, ¶m_obj) + && json_object_object_get_ex(param_obj, _area, &area_obj)) { + AFB_INFO("request appid = %s.", value); + const char* area = json_object_get_string(area_obj); + ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value); + if(ret == AFB_REQ_NOT_STARTED_APPLICATION) { + g_hs_instance->client_manager->setStartupAppidAndArea(make_pair(std::string(value), std::string(area))); + std::string id = g_hs_instance->app_info->getAppProperty(value, _keyId); + HS_AfmMainProxy afm_proxy; + afm_proxy.start(request->api, id); + ret = 0; + } + } + else { + ret = AFB_EVENT_BAD_REQUEST; } - // response to HomeScreen - struct json_object *res = json_object_new_object(); - hs_add_object_to_json_object_func(res, __FUNCTION__, 2, - _error, ret); - afb_req_success(request, res, "afb_event_push event [tap_shortcut]"); + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [tap_shortcut]"); + } } /** @@ -84,19 +369,17 @@ static void tap_shortcut (afb_req_t request) */ static void on_screen_message (afb_req_t request) { - HMI_NOTICE("homescreen-service","called."); - - int ret = g_client_manager->on_screen_message(request); - if (ret != 0) { - afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); - return; + AFB_DEBUG("called."); + int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__); + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [on_screen_message]"); } - - // response to HomeScreen - struct json_object *res = json_object_new_object(); - hs_add_object_to_json_object_func(res, __FUNCTION__, 2, - _error, ret); - afb_req_success(request, res, "afb_event_push event [on_screen_message]"); } /** @@ -112,19 +395,17 @@ static void on_screen_message (afb_req_t request) */ static void on_screen_reply (afb_req_t request) { - HMI_NOTICE("homescreen-service","called."); - - int ret = g_client_manager->on_screen_reply(request); - if (ret != 0) { - afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); - return; + AFB_DEBUG("called."); + int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__); + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [on_screen_reply]"); } - - // response to HomeScreen - struct json_object *res = json_object_new_object(); - hs_add_object_to_json_object_func(res, __FUNCTION__, 2, - _error, ret); - afb_req_success(request, res, "afb_event_push event [on_screen_reply]"); } /** @@ -139,19 +420,25 @@ static void on_screen_reply (afb_req_t request) */ static void subscribe(afb_req_t request) { - HMI_NOTICE("homescreen-service","called."); + AFB_DEBUG("called."); + int ret = 0; + std::string req_appid = std::move(get_application_id(request)); + if(!req_appid.empty()) { + ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, req_appid.c_str()); + } + else { + ret = AFB_EVENT_BAD_REQUEST; + } - int ret = g_client_manager->subscribe(request); if(ret) { - afb_req_fail_f(request, "afb_req_subscribe failed", "called %s.", __FUNCTION__); - return; + afb_req_fail_f(request, "afb_req_subscribe failed", "called %s.", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success_f(request, res, "homescreen binder subscribe."); } - - /*create response json object*/ - struct json_object *res = json_object_new_object(); - hs_add_object_to_json_object_func(res, __FUNCTION__, 2, - _error, ret); - afb_req_success_f(request, res, "homescreen binder subscribe."); } /** @@ -166,21 +453,280 @@ static void subscribe(afb_req_t request) */ static void unsubscribe(afb_req_t request) { - HMI_NOTICE("homescreen-service","called."); + AFB_DEBUG("called."); + int ret = 0; + std::string req_appid = std::move(get_application_id(request)); + if(!req_appid.empty()) { + ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, req_appid.c_str()); + } + else { + ret = AFB_EVENT_BAD_REQUEST; + } - int ret = g_client_manager->unsubscribe(request); if(ret) { - afb_req_fail_f(request, "afb_req_unsubscribe failed", "called %s.", __FUNCTION__); - return; + afb_req_fail_f(request, "afb_req_unsubscribe failed", "called %s.", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success_f(request, res, "homescreen binder unsubscribe success."); } +} + +/** + * showWindow event + * + * #### Parameters + * - request : the request + * + * #### Return + * None + * + */ +static void showWindow(afb_req_t request) +{ + AFB_DEBUG("called."); + int ret = 0; + struct json_object *param_obj, *area_obj; + const char* value = afb_req_value(request, _application_id); + if (value + && json_object_object_get_ex(afb_req_json(request), _parameter, ¶m_obj) + && json_object_object_get_ex(param_obj, _area, &area_obj)) { + const char* area = json_object_get_string(area_obj); + ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value); + if(ret == AFB_REQ_NOT_STARTED_APPLICATION) { + g_hs_instance->client_manager->setStartupAppidAndArea(make_pair(std::string(value), std::string(area))); + std::string id = g_hs_instance->app_info->getAppProperty(value, _keyId); + HS_AfmMainProxy afm_proxy; + afm_proxy.start(request->api, id); + ret = 0; + } + } + else { + ret = AFB_EVENT_BAD_REQUEST; + } + + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [showWindow]"); + } +} + +/** + * hideWindow event + * + * #### Parameters + * - request : the request + * + * #### Return + * None + * + */ +static void hideWindow(afb_req_t request) +{ + AFB_DEBUG("called."); + int ret = 0; + const char* value = afb_req_value(request, _application_id); + if (value) { + ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value); + } + else { + ret = AFB_EVENT_BAD_REQUEST; + } + + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [hideWindow]"); + } +} + +/** + * replyShowWindow event + * + * #### Parameters + * - request : the request + * + * #### Return + * None + * + */ +static void replyShowWindow(afb_req_t request) +{ + AFB_DEBUG("called."); + int ret = 0; + const char* value = afb_req_value(request, _application_id); + if (value) { + ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value); + } + else { + ret = AFB_EVENT_BAD_REQUEST; + } + + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [replyShowWindow]"); + } +} + +/** + * showNotification event + * + * the contents to homescreen which display at top area. + * + * #### Parameters + * - request : the request + * + * #### Return + * None + * + */ +static void showNotification(afb_req_t request) +{ + AFB_DEBUG("called."); + int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, "homescreen"); + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [showNotification]"); + } +} + +/** + * showInformation event + * + * the contents to homescreen which display at bottom area. + * + * #### Parameters + * - request : the request + * + * #### Return + * None + * + */ +static void showInformation(afb_req_t request) +{ + AFB_DEBUG("called."); + int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, "homescreen"); + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [showInformation]"); + } +} + +/** + * get runnables list + * + * #### Parameters + * - request : the request + * + * #### Return + * None + * + */ +static void getRunnables(afb_req_t request) +{ + AFB_DEBUG("called."); + struct json_object* j_runnable = json_object_new_array(); + g_hs_instance->app_info->getRunnables(&j_runnable); /*create response json object*/ struct json_object *res = json_object_new_object(); - hs_add_object_to_json_object_func(res, __FUNCTION__, 2, - _error, ret); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, _error, 0); + json_object_object_add(res, _keyData, j_runnable); afb_req_success_f(request, res, "homescreen binder unsubscribe success."); } +/** + * registerShortcut event + * + * #### Parameters + * - value : the json contents to MenuBar. + * {"application_id":"homescreen","parameter":{"shortcut_id":"dashboard@0.1","shortcut_name":"Dashboard","postion": 1}} + * + * #### Return + * None + * + */ +static void registerShortcut(afb_req_t request) +{ + int ret = 0; + const char* value = afb_req_value(request, _application_id); + if (value) { + ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value); + } + else { + ret = AFB_EVENT_BAD_REQUEST; + } + + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [registerShortcut]"); + } +} + +/** + * updateShortcut event + * + * #### Parameters + * - value : homescreen shortcut json contents. + * {"application_id":"launcher","parameter":{"shortcut":[{"shortcut_id":"hvac","shortcut_name":"HVAC"},...]}} + * + * #### Return + * None + * + */ +static void updateShortcut(afb_req_t request) +{ + int ret = 0; + const char* value = afb_req_value(request, _application_id); + if (value) { + ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value); + } + else { + ret = AFB_EVENT_BAD_REQUEST; + } + + if (ret) { + afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__); + } + else { + struct json_object *res = json_object_new_object(); + hs_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + afb_req_success(request, res, "afb_event_push event [updateShortcut]"); + } +} + /* * array of the verbs exported to afb-daemon */ @@ -188,10 +734,18 @@ static const afb_verb_t verbs[]= { /* VERB'S NAME FUNCTION TO CALL */ { .verb="ping", .callback=pingSample }, { .verb="tap_shortcut", .callback=tap_shortcut }, + { .verb="showWindow", .callback=showWindow }, + { .verb="hideWindow", .callback=hideWindow }, + { .verb="replyShowWindow", .callback=replyShowWindow }, { .verb="on_screen_message", .callback=on_screen_message }, { .verb="on_screen_reply", .callback=on_screen_reply }, { .verb="subscribe", .callback=subscribe }, { .verb="unsubscribe", .callback=unsubscribe }, + { .verb="showNotification", .callback=showNotification }, + { .verb="showInformation", .callback=showInformation }, + { .verb="registerShortcut", .callback=registerShortcut }, + { .verb="getRunnables", .callback=getRunnables }, + { .verb="updateShortcut", .callback=updateShortcut }, {NULL } /* marker for end of the array */ }; @@ -207,8 +761,8 @@ static const afb_verb_t verbs[]= { */ static int preinit(afb_api_t api) { - HMI_NOTICE("homescreen-service","binding preinit (was register)"); - return 0; + AFB_DEBUG("binding preinit (was register)"); + return 0; } /** @@ -223,11 +777,23 @@ static int preinit(afb_api_t api) */ static int init(afb_api_t api) { - HMI_NOTICE("homescreen-service","binding init"); + AFB_DEBUG("binding init"); - g_client_manager->init(); + if(g_hs_instance != nullptr) { + AFB_WARNING( "g_hs_instance isn't null."); + delete g_hs_instance->client_manager; + delete g_hs_instance->app_info; + delete g_hs_instance->app_recover; + delete g_hs_instance; + g_hs_instance = nullptr; + } + g_hs_instance = new hs_instance(); + if(g_hs_instance == nullptr) { + AFB_ERROR( "Fatal Error: new g_hs_instance failed."); + return -1; + } - return 0; + return g_hs_instance->init(api); } /** @@ -244,7 +810,8 @@ static int init(afb_api_t api) */ static void onevent(afb_api_t api, const char *event, struct json_object *object) { - HMI_NOTICE("homescreen-service","on_event %s", event); + AFB_INFO("on_event %s", event); + g_hs_instance->onEvent(api, event, object); } const afb_binding_t afbBindingExport = {