<param name="urn:AGL:permission:afm:system:widget" value="required" />
<param name="urn:AGL:permission:afm:system:runner" value="required" />
<param name="urn:AGL:permission:afm:system:widget:start" value="required" />
+ <param name="urn:AGL:permission:vshl-capabilities:navigation:public" value="required" />
</feature>
<feature name="urn:AGL:widget:provided-api">
<param name="homescreen" value="ws" />
<feature name="urn:AGL:widget:required-api">
<param name="afm-main" value="ws" />
<param name="windowmanager" value="ws" />
+ <param name="vshl-capabilities" value="ws" />
</feature>
<feature name="urn:AGL:widget:required-binding">
<param name="lib/homescreen-service.so" value="local" />
hs-proxy.cpp
hs-appinfo.cpp
hs-config.cpp
- hs-apprecover.cpp)
+ hs-apprecover.cpp
+ hs-vuiadapter.cpp)
link_libraries(-Wl,--as-needed -Wl,--gc-sections -Wl,--no-undefined)
include_directories(${PROJECT_SOURCE_DIR}/include)
#include "hs-appinfo.h"
#include "hs-config.h"
#include "hs-apprecover.h"
-
+#include "hs-vuiadapter.h"
const char _error[] = "error";
struct hs_instance {
HS_ClientManager *client_manager; // the connection session manager
HS_AppInfo *app_info; // application info
- HS_AppRecover *app_recover;
+ HS_AppRecover *app_recover; // application recover
+ HS_VuiAdapter * vui_adapter; // vui function adapter
- hs_instance() : client_manager(HS_ClientManager::instance()), app_info(HS_AppInfo::instance()), app_recover(HS_AppRecover::instance()) {}
+ hs_instance() : client_manager(HS_ClientManager::instance()), app_info(HS_AppInfo::instance()), app_recover(HS_AppRecover::instance()), vui_adapter(HS_VuiAdapter::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);
return -1;
}
+ if(vui_adapter == nullptr) {
+ AFB_ERROR("vui_adapter is nullptr.");
+ }
+ vui_adapter->init(api);
+
return 0;
}
*/
void hs_instance::setEventHook(const char *event, const event_hook_func f)
{
+ AFB_INFO("hook event %s", event);
if(event == nullptr || f == nullptr) {
AFB_WARNING("argument is null.");
return;
break;
}
}
+ else {
+ AFB_INFO("don't find hook event %s", event);
+ }
}
/**
*/
static void tap_shortcut (afb_req_t request)
{
- AFB_DEBUG("called.");
int ret = 0;
const char* value = afb_req_value(request, _application_id);
if (value) {
*/
static void on_screen_message (afb_req_t request)
{
- 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__);
*/
static void on_screen_reply (afb_req_t request)
{
- 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__);
*/
static void subscribe(afb_req_t request)
{
- AFB_DEBUG("called.");
int ret = 0;
std::string req_appid = std::move(get_application_id(request));
if(!req_appid.empty()) {
*/
static void unsubscribe(afb_req_t request)
{
- AFB_DEBUG("called.");
int ret = 0;
std::string req_appid = std::move(get_application_id(request));
if(!req_appid.empty()) {
*/
static void showWindow(afb_req_t request)
{
- AFB_DEBUG("called.");
int ret = 0;
const char* value = afb_req_value(request, _application_id);
if (value) {
*/
static void hideWindow(afb_req_t request)
{
- AFB_DEBUG("called.");
int ret = 0;
const char* value = afb_req_value(request, _application_id);
if (value) {
*/
static void replyShowWindow(afb_req_t request)
{
- AFB_DEBUG("called.");
int ret = 0;
const char* value = afb_req_value(request, _application_id);
if (value) {
*/
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__);
*/
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__);
*/
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);
{ .verb="unsubscribe", .callback=unsubscribe },
{ .verb="showNotification", .callback=showNotification },
{ .verb="showInformation", .callback=showInformation },
- { .verb="registerShortcut", .callback=registerShortcut },
{ .verb="getRunnables", .callback=getRunnables },
+ { .verb="registerShortcut", .callback=registerShortcut },
{ .verb="updateShortcut", .callback=updateShortcut },
{NULL } /* marker for end of the array */
};
delete g_hs_instance->client_manager;
delete g_hs_instance->app_info;
delete g_hs_instance->app_recover;
+ delete g_hs_instance->vui_adapter;
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.");
+ AFB_ERROR( "new g_hs_instance failed.");
return -1;
}
*/
static void onevent(afb_api_t api, const char *event, struct json_object *object)
{
- AFB_INFO("on_event %s", event);
+ AFB_INFO("on_event %s, object %s", event, json_object_to_json_string(object));
g_hs_instance->onEvent(api, event, object);
}
{
afmmain = new HS_AfmMainProxy();
if(afmmain == nullptr) {
- AFB_ERROR("Fatal Error:new HS_AfmMainProxy failed");
+ AFB_ERROR("new HS_AfmMainProxy failed");
return -1;
}
*/
void HS_AppInfo::pushAppListChangedEvent(const char *oper, struct json_object *object)
{
- AFB_DEBUG("called.");
struct json_object *push_obj = json_object_new_object();
json_object_object_add(push_obj, _keyOperation, json_object_new_string(oper));
json_object_object_add(push_obj, _keyData, object);
*/
void HS_AppRecover::startRecovery(afb_api_t api)
{
+ this->addListenAppId(_listen_all);
+ HS_ClientManager::instance()->addListener(this);
+
for(auto &key : HS_Config::keys_recover_type) {
for(auto &m : recover_app_map[key]){
struct app_recover_info recover_info = {
}
/**
- * register started applications
+ * notify
*
* #### Parameters
- * - appid : application id liked "dashboard"
+ * - api : the api
+ * - appid : application id
*
* #### Return
- * false : not recover app
- * true : recover app
- *
+ * None
+ *
*/
-bool HS_AppRecover::registerRecoveredApp(afb_api_t api, const std::string &appid)
+void HS_AppRecover::notify(afb_api_t api, std::string appid)
{
- bool ret = false;
- if(m_recovering_set.empty()) {
- return ret;
- }
-
AFB_INFO("recover appid=[%s].", appid.c_str());
auto it = m_recovering_set.find(appid);
if(it != m_recovering_set.end()) {
&& ip->second.visibility) {
HS_ClientManager::instance()->pushEvent("showWindow", nullptr, appid);
}
- ret = true;
}
// check wait recover application
}
m_wait_recover_set.erase(appid);
}
- return ret;
+
+ if(m_recovering_set.empty()) {
+ HS_ClientManager::instance()->removeListener(this);
+ }
}
/**
#include <set>
#include "hs-helper.h"
#include "hs-config.h"
+#include "hs-clientmanager.h"
struct app_recover_info {
std::string recover_type;
std::string after;
};
-class HS_AppRecover {
+class HS_AppRecover : public listener_interface {
public:
- HS_AppRecover() = default;
+ HS_AppRecover() : listener_interface(std::string("hs_apprecover")) {}
~HS_AppRecover() = default;
HS_AppRecover(HS_AppRecover const &) = delete;
HS_AppRecover &operator=(HS_AppRecover const &) = delete;
int init(afb_api_t api);
void setRecoverMap(recover_map &map) {recover_app_map.swap(map);}
void startRecovery(afb_api_t api);
- bool registerRecoveredApp(afb_api_t api, const std::string &appid);
void screenUpdated(struct json_object *obj);
+ void notify(afb_api_t api, std::string appid = "");
private:
void startApplication(afb_api_t api, const std::string &appid);
*/
HS_Client::HS_Client(afb_req_t request, std::string id) : my_id(id)
{
- AFB_DEBUG("called.");
my_event = afb_api_make_event(request->api, id.c_str());
}
*/
HS_Client::~HS_Client()
{
- AFB_DEBUG("called.");
afb_event_unref(my_event);
}
*/
int HS_Client::subscribe(afb_req_t request)
{
- AFB_DEBUG(" called.");
int ret = 0;
const char *value = afb_req_value(request, _event);
if(value) {
*/
int HS_Client::unsubscribe(afb_req_t request)
{
- AFB_DEBUG(" called.");
int ret = 0;
const char *value = afb_req_value(request, _event);
if(value) {
*/
int HS_Client::hideWindow(afb_req_t request)
{
- AFB_DEBUG(" called.");
std::string req_appid = std::move(get_application_id(request));
if(req_appid.empty()) {
AFB_WARNING("can't get application identifier");
*/
int HS_Client::showNotification(afb_req_t request)
{
- AFB_DEBUG(" called.");
int ret = 0;
const char *value = afb_req_value(request, _text);
if(value) {
*/
int HS_Client::showInformation(afb_req_t request)
{
- AFB_DEBUG(" called.");
int ret = 0;
const char *value = afb_req_value(request, _info);
if(value) {
*/
int HS_Client::handleRequest(afb_req_t request, const char *verb)
{
- AFB_DEBUG("called.");
if((strcasecmp(verb, "subscribe") && strcasecmp(verb, "unsubscribe")) && !checkEvent(verb))
return 0;
if(!checkEvent(event))
return 0;
- AFB_INFO("called, event=%s.",event);
+ AFB_INFO("called, event=%s.", event);
struct json_object* push_obj = json_object_new_object();
hs_add_object_to_json_object_str( push_obj, 4, _application_id, my_id.c_str(), _type, event);
if(param != nullptr)
#include "hs-apprecover.h"
static const char _homescreen[] = "homescreen";
+const std::string _listen_all("all");
HS_ClientManager* HS_ClientManager::me = nullptr;
*/
int HS_ClientManager::init(void)
{
- AFB_NOTICE("called.");
+ listener_list.clear();
+ std::list<listener_interface*> interface_list;
+ listener_list[_listen_all] = std::move(interface_list);
}
/**
}
}
if(isRegisterApp) {
- checkRegisterApp(request->api, std::string(appid));
+ notifyListener(request->api, std::string(appid));
}
return ret;
}
* - appid : register application's id
*
* #### Return
+ * true : checked
+ * false : not checked
+ *
+ */
+bool HS_ClientManager::checkRegisterApp(afb_api_t api, const std::string &appid)
+{
+ bool ret = true;
+ auto &ip = listener_list[_listen_all];
+ if(!ip.empty()) {
+ for(auto &it : ip) {
+ it->notify(api, appid);
+ }
+ }
+ else if(startup_appid == appid) {
+ startup_appid.clear();
+ pushEvent("showWindow", nullptr, appid);
+ }
+ else {
+ ret = false;
+ }
+ return ret;
+}
+
+/**
+ * check whether application was started
+ *
+ * #### Parameters
+ * - appid : application's id
+ *
+ * #### Return
+ * true : started
+ * false : not start
+ *
+ */
+bool HS_ClientManager::isAppStarted(const std::string &appid)
+{
+ auto it = client_list.find(appid);
+ return it != client_list.end() ? true : false;
+}
+
+/**
+ * add app register listener
+ *
+ * #### Parameters
+ * - listener_interface : listener interface
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_ClientManager::addListener(listener_interface* listener)
+{
+ for (auto &it : listener->listenAppSet()) {
+ auto ip = listener_list.find(it);
+ if(ip != listener_list.end()) {
+ ip->second.push_back(listener);
+ }
+ else {
+ std::list<listener_interface*> lst;
+ lst.push_back(listener);
+ listener_list[it] = std::move(lst);
+ }
+ }
+}
+
+/**
+ * remove app register listener
+ *
+ * #### Parameters
+ * - listener_interface : listener interface
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_ClientManager::removeListener(listener_interface* listener)
+{
+ for (auto &iter : listener->listenAppSet()) {
+ auto it = listener_list.find(iter);
+ if(it != listener_list.end()) {
+ auto ip = it->second.begin();
+ for(; ip != it->second.end(); ++ip) {
+ if(listener->myUid() == (*ip)->myUid()) {
+ break;
+ }
+ }
+ it->second.erase(ip);
+ if(it->second.empty()) {
+ listener_list.erase(it->first);
+ }
+ }
+ }
+}
+
+/**
+ * notify listener
+ *
+ * #### Parameters
+ * - api : the api
+ * - appid : register application's id
+ *
+ * #### Return
* None
*
*/
-void HS_ClientManager::checkRegisterApp(afb_api_t api, const std::string &appid)
+void HS_ClientManager::notifyListener(afb_api_t api, const std::string &appid)
{
- if(HS_AppRecover::instance()->registerRecoveredApp(api, appid)) {
- AFB_INFO("register recover application %s.", appid.c_str());
+ if (checkRegisterApp(api, appid)) {
return;
}
- if(startup_appid == appid) {
- startup_appid.clear();
- pushEvent("showWindow", nullptr, appid);
+ AFB_INFO("listen %s, notified", appid.c_str());
+ std::list<listener_interface*> interface_list;
+ auto ip = listener_list.find(appid);
+ if(ip != listener_list.end()) {
+ if(!ip->second.empty()) {
+ interface_list = ip->second;
+ }
+ else {
+ AFB_WARNING("listener is null.");
+ return;
+ }
+ }
+
+ for(auto &it : interface_list) {
+ it->notify(api, appid);
}
+
}
\ No newline at end of file
#include <mutex>
#include <memory>
#include <unordered_map>
+#include <list>
+#include <set>
#include "hs-helper.h"
#include "hs-client.h"
+extern const std::string _listen_all;
+
+class listener_interface {
+public:
+ listener_interface(std::string uid, std::set<std::string> listen_appid = std::set<std::string>()) : m_uid(uid), m_listen_appid(listen_appid) {}
+ virtual ~listener_interface() {}
+ virtual void notify(afb_api_t api, std::string appid = "") = 0;
+ std::string myUid(void) {return m_uid;}
+ std::set<std::string> listenAppSet(void) {return m_listen_appid;}
+ void addListenAppId(std::string appid) {m_listen_appid.insert(appid);}
+ bool isListenAppId(std::string &appid) {
+ auto it = m_listen_appid.find(appid);
+ return it != m_listen_appid.end() ? true : false;
+ }
+ bool listenAppEmpty(void) {return m_listen_appid.empty();}
+ void clearListenAppSet(void) {m_listen_appid.clear();}
+private:
+ std::string m_uid;
+ std::set<std::string> m_listen_appid;
+};
+
typedef struct HS_ClientCtxt
{
std::string id;
int pushEvent(const char *event, struct json_object *param, std::string appid = "");
void removeClientCtxt(void *data); // don't use, internal only
void setStartupAppid(const std::string &appid) {startup_appid = appid;}
+ bool isAppStarted(const std::string &appid);
+ void addListener(listener_interface* listener);
+ void removeListener(listener_interface* listener);
private:
HS_ClientCtxt* createClientCtxt(afb_req_t req, std::string appid);
HS_Client* addClient(afb_req_t req, std::string appid);
void removeClient(std::string appid);
- void checkRegisterApp(afb_api_t api, const std::string &appid);
+ bool checkRegisterApp(afb_api_t api, const std::string &appid);
+ void notifyListener(afb_api_t api, const std::string &appid);
private:
static HS_ClientManager* me;
+ std::unordered_map<std::string, std::list<listener_interface*>> listener_list;
std::unordered_map<std::string, HS_Client*> client_list;
std::unordered_map<std::string, HS_ClientCtxt*> appid2ctxt;
std::mutex mtx;
"application-list-changed",
"registerShortcut",
"updateShortcut",
+ "setDestination",
+ "cancelDestination",
+ "startNavigation",
+ "stopNavigation",
"reserved"
};
#include "hs-proxy.h"
-static const char _afm_main[] = "afm-main";
-static const char _windowmanager[] = "windowmanager";
-static const char _event[] = "event";
+const char _afm_main[] = "afm-main";
+const char _windowmanager[] = "windowmanager";
+const char _event[] = "event";
+const char _vshl_capabilities[] = "vshl-capabilities";
+const char _actions[] = "actions";
/**
* the callback function
json_object_object_add(push_obj, _event, json_object_new_int(event));
api_call(api, _windowmanager, "wm_subscribe", push_obj, f);
}
+
+/* -------------------------------------HS_VshlCapabilitiesProxy------------------------------------------ */
+
+/**
+ * subscribe event
+ *
+ * #### Parameters
+ * - api : the api
+ * - module : module name
+ * - ev_list : event list
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_VshlCapabilitiesProxy::subscribe(afb_api_t api, const std::string &module, const std::list<std::string> &ev_list)
+{
+ if(ev_list.empty()) {
+ return;
+ }
+
+ struct json_object *arr_obj = json_object_new_array();
+ for(auto &it : ev_list) {
+ json_object_array_add(arr_obj, json_object_new_string(it.c_str()));
+ }
+ struct json_object *args = json_object_new_object();
+ json_object_object_add(args, _actions, arr_obj);
+
+ std::string verb = module + '/' + __FUNCTION__;
+ api_call(api, _vshl_capabilities, verb.c_str(), args);
+}
\ No newline at end of file
#include <string>
#include <json-c/json.h>
#include <functional>
+#include <list>
#include "hs-helper.h"
+extern const char _afm_main[];
+extern const char _vshl_capabilities[];
+
typedef void (*api_cb_func)(struct json_object *obj, const char *error, const char *info);
class HS_AfmMainProxy {
void subscribe(afb_api_t api, EventType event, api_cb_func f = nullptr);
};
+struct HS_VshlCapabilitiesProxy {
+ // asynchronous call, reply in callback function
+ void subscribe(afb_api_t api, const std::string &module, const std::list<std::string> &ev_list);
+};
+
#endif // HOMESCREEN_PROXY_H
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2019 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-vuiadapter.h"
+#include "hs-clientmanager.h"
+#include "hs-proxy.h"
+#include "hs-appinfo.h"
+
+/**
+ * event handler
+ *
+ * #### 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 event_handler(afb_api_t api, const char *event, struct json_object *object)
+{
+ return HS_VuiAdapter::instance()->onEvent(api, event, object);
+}
+
+/* -------------------------------------Vui_Navigation------------------------------------------ */
+
+const std::map<std::string, Vui_Navigation::func_handler> Vui_Navigation::func_list = {
+ {"set_destination", &Vui_Navigation::set_destination},
+ {"cancel_navigation", &Vui_Navigation::cancel_navigation}
+};
+const char _vui_prefixe[] = "vui";
+const char _poi[] = "poi";
+const char _navigation[] = "navigation";
+const char _destination[] = "destination";
+const char _coordinate[] = "coordinate";
+const char _latitudeInDegrees[] = "latitudeInDegrees";
+const char _longitudeInDegrees[] = "longitudeInDegrees";
+const char _setDestination[] = "setDestination";
+const char _cancelDestination[] = "cancelDestination";
+const char _startNavigation[] = "startNavigation";
+const char _stopNavigation[] = "stopNavigation";
+
+/**
+ * init
+ *
+ * #### Parameters
+ * - api : the api
+ *
+ * #### Return
+ * None
+ *
+ */
+void Vui_Navigation::init(afb_api_t api)
+{
+ std::list<std::string> ev_list;
+ for(auto &it : func_list) {
+ ev_list.push_back(it.first);
+ std::string ev_name = std::string(_vshl_capabilities) + '/' + it.first;
+ AFB_INFO("setEventHook event %s", ev_name.c_str());
+ setEventHook(ev_name.c_str(), event_handler);
+ }
+ HS_VshlCapabilitiesProxy proxy;
+ proxy.subscribe(api, _navigation, ev_list);
+}
+
+/**
+ * handle event
+ *
+ * #### Parameters
+ * - api : the api serving the request
+ * - event : event name
+ * - object : event json object
+ *
+ * #### Return
+ * 0 : continue transfer
+ * 1 : blocked
+ *
+ */
+int Vui_Navigation::onEvent(afb_api_t api, const char *event, struct json_object *object)
+{
+ std::string ev(event);
+ auto pos = ev.find('/');
+ auto ip = func_list.find(ev.substr(pos + 1));
+ int ret = 0;
+ if(ip != func_list.end()) {
+ (this->*(ip->second))(api, object);
+ ret = 1;
+ }
+ return ret;
+}
+
+/**
+ * set_destination event handler
+ *
+ * #### Parameters
+ * - api : the api serving the reques
+ * - object : event json object
+ *
+ * #### Return
+ * None
+ *
+ */
+void Vui_Navigation::set_destination(afb_api_t api, struct json_object *object)
+{
+ AFB_INFO("set dest: %s", json_object_to_json_string(object));
+ struct json_object *j_dest, *j_coord, *j_latitude, *j_longitude;
+ struct json_object *j_obj = json_tokener_parse(json_object_get_string(object));
+ if(json_object_object_get_ex(j_obj, _destination, &j_dest)
+ && json_object_object_get_ex(j_dest, _coordinate, &j_coord)
+ && json_object_object_get_ex(j_coord, _latitudeInDegrees, &j_latitude)
+ && json_object_object_get_ex(j_coord, _longitudeInDegrees, &j_longitude)) {
+ m_dest = std::make_pair(json_object_get_double(j_latitude), json_object_get_double(j_longitude));
+ }
+ else {
+ AFB_WARNING("input data error.");
+ return;
+ }
+
+ auto b_pair = std::make_pair<bool, bool>(false, false);
+ if(HS_ClientManager::instance()->isAppStarted(std::string(_poi))) {
+ b_pair.first = true;
+ set_destination2poi(api);
+ }
+ else {
+ this->addListenAppId(_poi);
+ std::string id = HS_AppInfo::instance()->getAppProperty(_poi, _keyId);
+ HS_AfmMainProxy afm_proxy;
+ afm_proxy.start(api, id);
+ }
+
+ if(HS_ClientManager::instance()->isAppStarted(std::string(_navigation))) {
+ b_pair.second = true;
+ start_navigation(api);
+ }
+ else {
+ this->addListenAppId(_navigation);
+ std::string id = HS_AppInfo::instance()->getAppProperty(_navigation, _keyId);
+ HS_AfmMainProxy afm_proxy;
+ afm_proxy.start(api, id);
+ }
+ m_start_flg.swap(b_pair);
+ if (!listenAppEmpty()) {
+ HS_ClientManager::instance()->addListener(this);
+ }
+}
+
+/**
+ * cancel_navigation event handler
+ *
+ * #### Parameters
+ * - api : the api serving the reques
+ * - object : event json object
+ *
+ * #### Return
+ * None
+ *
+ */
+void Vui_Navigation::cancel_navigation(afb_api_t api, struct json_object *object)
+{
+ HS_ClientManager::instance()->pushEvent(_stopNavigation, nullptr);
+}
+
+/**
+ * notify
+ *
+ * #### Parameters
+ * - api : the api
+ * - appid : application id
+ *
+ * #### Return
+ * None
+ *
+ */
+void Vui_Navigation::notify(afb_api_t api, std::string appid)
+{
+ if(isListenAppId(appid)) {
+ if (appid == _poi) {
+ m_start_flg.first = true;
+ set_destination2poi(api);
+ }
+ else if(appid == _navigation) {
+ m_start_flg.second = true;
+ start_navigation(api);
+ }
+ else {
+ AFB_WARNING("%s isn't interest app.", appid.c_str());
+ return;
+ }
+ }
+ if(m_start_flg.first && m_start_flg.second) {
+ HS_ClientManager::instance()->removeListener(this);
+ clearListenAppSet();
+ }
+}
+
+/**
+ * set destination to poiapp
+ *
+ * #### Parameters
+ * - api : the api
+ *
+ * #### Return
+ * None
+ *
+ */
+void Vui_Navigation::set_destination2poi(afb_api_t api)
+{
+ struct json_object *param = json_object_new_object();
+ json_object_object_add(param, _latitudeInDegrees, json_object_new_double(m_dest.first));
+ json_object_object_add(param, _longitudeInDegrees, json_object_new_double(m_dest.second));
+ HS_ClientManager::instance()->pushEvent(_setDestination, param);
+}
+
+/**
+ * set destination and start navigation
+ *
+ * #### Parameters
+ * - api : the ap
+ *
+ * #### Return
+ * None
+ *
+ */
+void Vui_Navigation::start_navigation(afb_api_t api)
+{
+ HS_ClientManager::instance()->pushEvent(_startNavigation, nullptr);
+}
+
+/* -------------------------------------HS_VuiAdapter------------------------------------------ */
+
+HS_VuiAdapter* HS_VuiAdapter::me = nullptr;
+
+/**
+ * get instance
+ *
+ * #### Parameters
+ * - Nothing
+ *
+ * #### Return
+ * HS_VuiAdapter instance pointer
+ *
+ */
+HS_VuiAdapter* HS_VuiAdapter::instance(void)
+{
+ if(me == nullptr)
+ me = new HS_VuiAdapter();
+
+ return me;
+}
+
+/**
+ * init
+ *
+ * #### Parameters
+ * - api : the api
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_VuiAdapter::init(afb_api_t api)
+{
+ std::string uid = std::string(_vui_prefixe) + std::string("-") + _navigation;
+ module_list[uid] = new Vui_Navigation(uid);
+
+ for(auto &it : module_list) {
+ it.second->init(api);
+ }
+}
+
+/**
+ * handle event
+ *
+ * #### Parameters
+ * - api : the api serving the request
+ * - event : event name
+ * - object : event json object
+ *
+ * #### Return
+ * 0 : continue transfer
+ * 1 : blocked
+ *
+ */
+int HS_VuiAdapter::onEvent(afb_api_t api, const char *event, struct json_object *object)
+{
+ for(auto &it : module_list) {
+ if(it.second->onEvent(api, event, object))
+ return 1;
+ }
+ return 0;
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2019 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_VUIADAPTER_H
+#define HOMESCREEN_VUIADAPTER_H
+
+#include <map>
+#include <memory>
+#include <utility>
+#include "hs-helper.h"
+#include "hs-clientmanager.h"
+
+class Vui_ModuleBase {
+public:
+ explicit Vui_ModuleBase(std::string uid) : m_uid(uid) {}
+ virtual ~Vui_ModuleBase() {}
+ virtual void init(afb_api_t api) = 0;
+ virtual int onEvent(afb_api_t api, const char *event, struct json_object *object) = 0;
+ std::string mouduleId(void) {return m_uid;}
+
+private:
+ std::string m_uid;
+};
+
+class Vui_Navigation : public Vui_ModuleBase, public listener_interface {
+public:
+ explicit Vui_Navigation(std::string uid) : Vui_ModuleBase(uid), listener_interface(uid) {}
+ ~Vui_Navigation() = default;
+
+ virtual void init(afb_api_t api);
+ virtual int onEvent(afb_api_t api, const char *event, struct json_object *object);
+ virtual void notify(afb_api_t api, std::string appid = "");
+
+private:
+ void set_destination(afb_api_t api, struct json_object *object);
+ void cancel_navigation(afb_api_t api, struct json_object *object);
+ void set_destination2poi(afb_api_t api);
+ void start_navigation(afb_api_t api);
+
+ typedef void (Vui_Navigation::*func_handler)(afb_api_t, struct json_object *object);
+ static const std::map<std::string, func_handler> func_list;
+ std::pair<double, double> m_dest;
+ std::pair<bool, bool> m_start_flg;
+};
+
+class HS_VuiAdapter {
+public:
+ HS_VuiAdapter() = default;
+ ~HS_VuiAdapter() = default;
+ HS_VuiAdapter(HS_VuiAdapter const &) = delete;
+ HS_VuiAdapter &operator=(HS_VuiAdapter const &) = delete;
+ HS_VuiAdapter(HS_VuiAdapter &&) = delete;
+ HS_VuiAdapter &operator=(HS_VuiAdapter &&) = delete;
+
+ static HS_VuiAdapter* instance(void);
+ void init(afb_api_t api);
+ int onEvent(afb_api_t api, const char *event, struct json_object *object);
+
+private:
+ static HS_VuiAdapter* me;
+ std::map<std::string, Vui_ModuleBase*> module_list;
+};
+
+#endif // HOMESCREEN_VUIADAPTER_H
\ No newline at end of file
Code Review / apps / agl-service-homescreen.git / commitdiff