pkg_check_modules(hs_binding_depends afb-daemon glib-2.0 gio-2.0 gio-unix-2.0 json-c)
set(binding_hs_sources
homescreen.cpp
- hs-helper.cpp)
+ hs-helper.cpp
+ hs-clientmanager.cpp
+ hs-client.cpp)
link_libraries(-Wl,--as-needed -Wl,--gc-sections -Wl,--no-undefined)
include_directories(${PROJECT_SOURCE_DIR}/include)
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
+#include <memory>
+#include <algorithm>
#include "hs-helper.h"
#include "hmi-debug.h"
+#include "hs-clientmanager.h"
-#define COMMAND_EVENT_NUM 4
#define EVENT_SUBSCRIBE_ERROR_CODE 100
-/* To Do hash table is better */
-struct event{
- const char* name;
- struct afb_event event;
-};
-
-static struct event event_list[COMMAND_EVENT_NUM];
+const char _error[] = "error";
+const char _application_name[] = "application_name";
+const char _display_message[] = "display_message";
+const char _reply_message[] = "reply_message";
-static const char _error[] = "error";
-static const char _application_name[] = "application_name";
-static const char _display_message[] = "display_message";
-static const char _reply_message[] = "reply_message";
+static HS_ClientManager* g_client_manager = HS_ClientManager::instance();
/*
********** Method of HomeScreen Service (API) **********
int ret = 0;
const char* value = afb_req_value(request, _application_name);
if (value) {
-
HMI_NOTICE("homescreen-service","request params = %s.", value);
-
- struct json_object* push_obj = json_object_new_object();
- hs_add_object_to_json_object_str( push_obj, 2,
- _application_name, value);
- afb_event_push(event_list[hs_search_event_name_index(__FUNCTION__)].event, push_obj);
+ // first step get appid from appname, next step change appname to appid
+ std::string appid(value);
+ std::transform(appid.begin(), appid.end(), appid.begin(), ::tolower);
+ HS_Client* client = g_client_manager->find(appid);
+ if(client != nullptr) {
+ if(client->tap_shortcut(value) != 0) {
+ afb_req_fail_f(request, "afb_event_push failed", "called %s.", __FUNCTION__);
+ return;
+ }
+ }
+ else {
+ // app is not started, do nothing
+ }
} else {
afb_req_fail_f(request, "failed", "called %s, Unknown palameter", __FUNCTION__);
return;
if (value) {
HMI_NOTICE("homescreen-service","request params = %s.", value);
-
- struct json_object* push_obj = json_object_new_object();
- hs_add_object_to_json_object_str( push_obj, 2,
- _display_message, value);
- afb_event_push(event_list[hs_search_event_name_index(__FUNCTION__)].event, push_obj);
+ for(auto m : g_client_manager->getAllClient()) {
+ if(m->on_screen_message(request, value) != 0) {
+ afb_req_fail_f(request, "afb_event_push failed", "called %s.", __FUNCTION__);
+ return;
+ }
+ }
} else {
afb_req_fail_f(request, "failed", "called %s, Unknown palameter", __FUNCTION__);
return;
if (value) {
HMI_NOTICE("homescreen-service","request params = %s.", value);
-
- struct json_object* push_obj = json_object_new_object();
- hs_add_object_to_json_object_str( push_obj, 2,
- _reply_message, value);
- afb_event_push(event_list[hs_search_event_name_index(__FUNCTION__)].event, push_obj);
+ for(auto m : g_client_manager->getAllClient()) {
+ if(m->on_screen_reply(request, value) != 0) {
+ afb_req_fail_f(request, "afb_event_push failed", "called %s.", __FUNCTION__);
+ return;
+ }
+ }
} else {
afb_req_fail_f(request, "failed", "called %s, Unknown palameter", __FUNCTION__);
return;
HMI_NOTICE("homescreen-service","value is %s", value);
int ret = 0;
if(value) {
- int index = hs_search_event_name_index(value);
- if(index < 0)
- {
- HMI_NOTICE("homescreen-service","dedicated event doesn't exist");
- ret = EVENT_SUBSCRIBE_ERROR_CODE;
- }
- else
- {
- afb_req_subscribe(request, event_list[index].event);
+ std::string appid(afb_req_get_application_id(request));
+ std::transform(appid.begin(), appid.end(), appid.begin(), ::tolower);
+ if(g_client_manager->getClient(request, appid)->subscribe(request, value) != 0) {
+ afb_req_fail_f(request, "afb_req_subscribe failed", "called %s.", __FUNCTION__);
+ return;
}
}
- else{
+ else {
HMI_NOTICE("homescreen-service","Please input event name");
ret = EVENT_SUBSCRIBE_ERROR_CODE;
}
HMI_NOTICE("homescreen-service","value is %s", value);
int ret = 0;
if(value) {
- int index = hs_search_event_name_index(value);
- if(index < 0)
- {
- HMI_NOTICE("homescreen-service","dedicated event doesn't exist");
- ret = EVENT_SUBSCRIBE_ERROR_CODE;
+ std::string appid(afb_req_get_application_id(request));
+ std::transform(appid.begin(), appid.end(), appid.begin(), ::tolower);
+ HS_Client* client = g_client_manager->find(appid);
+ if(client != nullptr) {
+ if(client->unsubscribe(request, value) != 0) {
+ afb_req_fail_f(request, "afb_req_unsubscribe failed", "called %s.", __FUNCTION__);
+ return;
+ }
}
- else
- {
- afb_req_unsubscribe(request, event_list[index].event);
+ else {
+ HMI_NOTICE("homescreen-service","not find app's client, unsubscribe failed");
+ ret = EVENT_SUBSCRIBE_ERROR_CODE;
}
}
else{
{
HMI_NOTICE("homescreen-service","binding init");
- for(int i = 0; i < COMMAND_EVENT_NUM; ++i) {
- event_list[i].name = evlist[i];
- event_list[i].event = afb_daemon_make_event(evlist[i]);
- }
+ g_client_manager->init();
return 0;
}
--- /dev/null
+/*
+ * Copyright (c) 2018 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "hs-client.h"
+#include "hs-helper.h"
+#include "hmi-debug.h"
+
+static const char _type[] = "type";
+
+/**
+ * HS_Client construction function
+ *
+ * #### Parameters
+ * - id: app's id
+ *
+ * #### Return
+ * None
+ *
+ */
+HS_Client::HS_Client(struct afb_req request, std::string id) : my_id(id)
+{
+ HMI_NOTICE("homescreen-service","called.");
+ my_event = afb_daemon_make_event(id.c_str());
+}
+
+/**
+ * HS_Client destruction function
+ *
+ * #### Parameters
+ * - null
+ *
+ * #### Return
+ * None
+ *
+ */
+HS_Client::~HS_Client()
+{
+ HMI_NOTICE("homescreen-service","called.");
+ afb_event_unref(my_event);
+}
+
+/**
+ * push tap_shortcut event
+ *
+ * #### Parameters
+ * - appname: app's name.
+ *
+ * #### Return
+ * result
+ *
+ */
+int HS_Client::tap_shortcut(const char* appname)
+{
+ if(!checkEvent(__FUNCTION__))
+ return 0;
+
+ HMI_NOTICE("homescreen-service","%s application_name = %s.", __FUNCTION__, appname);
+ struct json_object* push_obj = json_object_new_object();
+ hs_add_object_to_json_object_str( push_obj, 4, _application_name, appname,
+ _type, __FUNCTION__);
+ return afb_event_push(my_event, push_obj);
+}
+
+/**
+ * push on_screen_message event
+ *
+ * #### Parameters
+ * - message: post message.
+ *
+ * #### Return
+ * result
+ *
+ */
+int HS_Client::on_screen_message(struct afb_req request, const char* message)
+{
+ if(!checkEvent(__FUNCTION__))
+ return 0;
+
+ HMI_NOTICE("homescreen-service","push %s event message [%s].", __FUNCTION__, message);
+ struct json_object* push_obj = json_object_new_object();
+ hs_add_object_to_json_object_str( push_obj, 4, _display_message, message,
+ _type, __FUNCTION__);
+ return afb_event_push(my_event, push_obj);
+}
+
+/**
+ * push on_screen_reply event
+ *
+ * #### Parameters
+ * - message: reply message.
+ *
+ * #### Return
+ * result
+ *
+ */
+int HS_Client::on_screen_reply(struct afb_req request, const char* message)
+{
+ if(!checkEvent(__FUNCTION__))
+ return 0;
+
+ HMI_NOTICE("homescreen-service","push %s event message [%s].", __FUNCTION__, message);
+ struct json_object* push_obj = json_object_new_object();
+ hs_add_object_to_json_object_str( push_obj, 4, _reply_message, message,
+ _type, __FUNCTION__);
+ return afb_event_push(my_event, push_obj);
+}
+
+/**
+ * subscribe event
+ *
+ * #### Parameters
+ * - event: homescreen event, tap_shortcut etc.
+ *
+ * #### Return
+ * result
+ *
+ */
+int HS_Client::subscribe(struct afb_req request, const char* event)
+{
+ int ret = 0;
+ auto ip = event_list.find(std::string(event));
+ if(ip == event_list.end()) {
+ event_list[std::string(event)] = 0;
+ ret = afb_req_subscribe(request, my_event);
+ }
+ return ret;
+}
+
+/**
+ * unsubscribe event
+ *
+ * #### Parameters
+ * - event: homescreen event, tap_shortcut etc.
+ *
+ * #### Return
+ * result
+ *
+ */
+int HS_Client::unsubscribe(struct afb_req request, const char* event)
+{
+ int ret = 0;
+ event_list.erase(std::string(event));
+ if(event_list.empty()) {
+ ret = afb_req_unsubscribe(request, my_event);
+ }
+ return ret;
+}
+
+/**
+ * check if client subscribe event
+ *
+ * #### Parameters
+ * - event: homescreen event, tap_shortcut etc.
+ *
+ * #### Return
+ * true: found
+ * false: not found
+ *
+ */
+bool HS_Client::checkEvent(const char* event)
+{
+ auto ip = event_list.find(std::string(event));
+ if(ip == event_list.end())
+ return false;
+ else
+ return true;
+}
--- /dev/null
+/*
+ * Copyright (c) 2018 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HOMESCREEN_CLIENT_H
+#define HOMESCREEN_CLIENT_H
+
+#include <string>
+#include <unordered_map>
+#include "hs-helper.h"
+
+
+class HS_Client {
+public:
+ HS_Client(struct afb_req request, const char* id) : HS_Client(request, std::string(id)){}
+ HS_Client(struct afb_req request, std::string id);
+ HS_Client(HS_Client&) = delete;
+ HS_Client &operator=(HS_Client&) = delete;
+ ~HS_Client();
+
+ int tap_shortcut(const char* appname);
+ int on_screen_message (struct afb_req request, const char* message);
+ int on_screen_reply (struct afb_req request, const char* message);
+ int subscribe(struct afb_req request, const char* event);
+ int unsubscribe(struct afb_req request, const char* event);
+
+private:
+ bool checkEvent(const char* event);
+
+private:
+ std::string my_id;
+ struct afb_event my_event;
+ std::unordered_map<std::string, int> event_list;
+
+};
+
+#endif // HOMESCREEN_CLIENT_H
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2018 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "hs-clientmanager.h"
+#include "hmi-debug.h"
+
+HS_ClientManager* HS_ClientManager::me = nullptr;
+
+static void cbRemoveClientCtxt(void *data)
+{
+ HS_ClientManager::instance()->removeClientCtxt(data);
+}
+
+/**
+ * HS_ClientManager construction function
+ *
+ * #### Parameters
+ * - Nothing
+ *
+ * #### Return
+ * None
+ *
+ */
+HS_ClientManager::HS_ClientManager()
+{
+}
+
+/**
+ * get instance
+ *
+ * #### Parameters
+ * - Nothing
+ *
+ * #### Return
+ * HS_ClientManager instance pointer
+ *
+ */
+HS_ClientManager* HS_ClientManager::instance(void)
+{
+ if(me == nullptr)
+ me = new HS_ClientManager();
+
+ return me;
+}
+
+/**
+ * HS_ClientManager init function
+ *
+ * #### Parameters
+ * - Nothing
+ *
+ * #### Return
+ * init result
+ *
+ */
+int HS_ClientManager::init(void)
+{
+ HMI_NOTICE("homescreen-service","called.");
+ // TODO : connect to windowmanger
+ // get applist from appfw
+}
+
+/**
+ * find HS_Client in client_list
+ *
+ * #### Parameters
+ * - appid: app's id
+ *
+ * #### Return
+ * found HS_Client pointer
+ *
+ */
+HS_Client* HS_ClientManager::find(std::string appid)
+{
+ std::lock_guard<std::mutex> lock(this->mtx);
+ HS_Client* p = nullptr;
+ auto ip = client_list.find(appid);
+ if(ip != client_list.end()) {
+ p = client_list[appid];
+ }
+ return p;
+}
+
+/**
+ * get HS_Client
+ *
+ * #### Parameters
+ * - appid: app's id
+ *
+ * #### Return
+ * found HS_Client pointer
+ *
+ */
+HS_Client* HS_ClientManager::getClient(afb_req req, std::string appid)
+{
+ std::lock_guard<std::mutex> lock(this->mtx);
+ HS_Client* p = nullptr;
+ auto ip = client_list.find(appid);
+ if(ip != client_list.end()) {
+ p = client_list[appid];
+ }
+ else {
+ appid2ctxt[appid] = createClientCtxt(req, appid);
+ p = addClient(req, appid);
+ }
+ return p;
+}
+
+/**
+ * get HS_Client pointers set
+ *
+ * #### Parameters
+ * - Nothing
+ *
+ * #### Return
+ * HS_Client pointers set
+ *
+ */
+std::vector<HS_Client*> HS_ClientManager::getAllClient(void)
+{
+ std::lock_guard<std::mutex> lock(this->mtx);
+ std::vector<HS_Client*> v;
+ for(auto a : client_list)
+ v.push_back(a.second);
+ return v;
+}
+
+/**
+ * create client's afb_req_context
+ *
+ * #### Parameters
+ * - appid: app's id
+ *
+ * #### Return
+ * HS_ClientCtxt pointer
+ *
+ */
+HS_ClientCtxt* HS_ClientManager::createClientCtxt(afb_req req, std::string appid)
+{
+ HS_ClientCtxt *ctxt = (HS_ClientCtxt *)afb_req_context_get(req);
+ if (!ctxt)
+ {
+ HMI_NOTICE("homescreen-service", "create new session for %s", appid.c_str());
+ HS_ClientCtxt *ctxt = new HS_ClientCtxt(appid.c_str());
+ afb_req_session_set_LOA(req, 1);
+ afb_req_context_set(req, ctxt, cbRemoveClientCtxt);
+ }
+ return ctxt;
+}
+
+/**
+ * add Client
+ *
+ * #### Parameters
+ * - ctxt: app's id
+ *
+ * #### Return
+ * HS_Client pointer
+ *
+ */
+HS_Client* HS_ClientManager::addClient(afb_req req, std::string appid)
+{
+ return (client_list[appid] = new HS_Client(req, appid));
+}
+
+/**
+ * remove Client
+ *
+ * #### Parameters
+ * - appid: app's id
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_ClientManager::removeClient(std::string appid)
+{
+ delete client_list[appid];
+ client_list.erase(appid);
+}
+
+/**
+ * remove Client from list
+ *
+ * #### Parameters
+ * - data: HS_ClientCtxt pointer
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_ClientManager::removeClientCtxt(void *data)
+{
+ HS_ClientCtxt *ctxt = (HS_ClientCtxt *)data;
+ if(ctxt == nullptr)
+ {
+ HMI_ERROR("homescreen-service", "data is nullptr");
+ return;
+ }
+
+ HMI_NOTICE("homescreen-service", "remove app %s", ctxt->id.c_str());
+ std::lock_guard<std::mutex> lock(this->mtx);
+ removeClient(ctxt->id);
+ delete appid2ctxt[ctxt->id];
+ appid2ctxt.erase(ctxt->id);
+}
--- /dev/null
+/*
+ * Copyright (c) 2018 TOYOTA MOTOR CORPORATION
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HOMESCREEN_CLIENTMANAGER_H
+#define HOMESCREEN_CLIENTMANAGER_H
+
+#include <string>
+#include <vector>
+#include <mutex>
+#include <memory>
+#include <unordered_map>
+#include "hs-helper.h"
+#include "hs-client.h"
+
+typedef struct HS_ClientCtxt
+{
+ std::string id;
+ HS_ClientCtxt(const char *appid)
+ {
+ id = appid;
+ }
+} HS_ClientCtxt;
+
+
+class HS_ClientManager {
+public:
+ HS_ClientManager();
+ ~HS_ClientManager() = default;
+ HS_ClientManager(HS_ClientManager const &) = delete;
+ HS_ClientManager &operator=(HS_ClientManager const &) = delete;
+ HS_ClientManager(HS_ClientManager &&) = delete;
+ HS_ClientManager &operator=(HS_ClientManager &&) = delete;
+
+ static HS_ClientManager* instance(void);
+ int init(void);
+ HS_Client* find(std::string appid);
+ HS_Client* getClient(afb_req req, std::string appid);
+ std::vector<HS_Client*> getAllClient(void);
+ void removeClientCtxt(void *data);
+
+private:
+ HS_ClientCtxt* createClientCtxt(afb_req req, std::string appid);
+ HS_Client* addClient(afb_req req, std::string appid);
+ void removeClient(std::string appid);
+
+private:
+ static HS_ClientManager* me;
+ std::unordered_map<std::string, HS_Client*> client_list;
+ std::unordered_map<std::string, HS_ClientCtxt*> appid2ctxt;
+ std::mutex mtx;
+};
+
+#endif // HOMESCREEN_CLIENTMANAGER_H
\ No newline at end of file
}REQ_ERROR;
extern const char* evlist[];
+extern const char _error[];
+extern const char _application_name[];
+extern const char _display_message[];
+extern const char _reply_message[];
REQ_ERROR get_value_uint16(const struct afb_req request, const char *source, uint16_t *out_id);
REQ_ERROR get_value_int16(const struct afb_req request, const char *source, int16_t *out_id);
Code Review / apps / agl-service-homescreen.git / commitdiff