aboutsummaryrefslogtreecommitdiffstats
path: root/src/hs-appinfo.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/hs-appinfo.cpp')
-rw-r--r--src/hs-appinfo.cpp492
1 files changed, 492 insertions, 0 deletions
diff --git a/src/hs-appinfo.cpp b/src/hs-appinfo.cpp
new file mode 100644
index 0000000..e1c1990
--- /dev/null
+++ b/src/hs-appinfo.cpp
@@ -0,0 +1,492 @@
+/*
+ * 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 <unistd.h>
+#include "hs-appinfo.h"
+#include "hmi-debug.h"
+#include "hs-clientmanager.h"
+
+#define RETRY_CNT 10
+
+const char _keyName[] = "name";
+const char _keyVersion[] = "version";
+const char _keyInstall[] = "install";
+const char _keyUninstall[] = "uninstall";
+const char _keyOperation[] = "operation";
+const char _keyRunnables[] = "runnables";
+const char _keyStart[] = "start";
+const char _keyApplistChanged[] = "application-list-changed";
+
+HS_AppInfo* HS_AppInfo::me = nullptr;
+
+/**
+ * get application property function
+ *
+ * #### Parameters
+ * - key : retrieve keyword
+ *
+ * #### Return
+ * retrieved property
+ *
+ */
+std::string AppDetail::getProperty(std::string key) const
+{
+ struct json_object *j_obj;
+ struct json_object *j_detail = json_tokener_parse(this->detail.c_str());
+ if(json_object_object_get_ex(j_detail, key.c_str(), &j_obj) == 0) {
+ HMI_ERROR("homescreen-service","can't find key=%s.", key.c_str());
+ return std::string();
+ }
+ return std::string(json_object_get_string(j_obj));
+}
+
+/**
+ * HS_AppInfo destruction function
+ *
+ * #### Parameters
+ * - Nothing
+ *
+ * #### Return
+ * None
+ *
+ */
+HS_AppInfo::~HS_AppInfo()
+{
+ if(afmmain)
+ delete afmmain;
+}
+
+/**
+ * get instance
+ *
+ * #### Parameters
+ * - Nothing
+ *
+ * #### Return
+ * HS_AppInfo instance pointer
+ *
+ */
+HS_AppInfo* HS_AppInfo::instance(void)
+{
+ if(me == nullptr)
+ me = new HS_AppInfo();
+
+ return me;
+}
+
+/**
+ * HS_AppInfo initialize function
+ *
+ * #### Parameters
+ * - api : the api serving the request
+ *
+ * #### Return
+ * 0 : init success
+ * 1 : init fail
+ *
+ */
+int HS_AppInfo::init(afb_api_t api)
+{
+ afmmain = new HS_AfmMainProxy();
+ if(afmmain == nullptr) {
+ HMI_ERROR("homescreen-service","Fatal Error:new HS_AfmMainProxy failed");
+ return -1;
+ }
+
+ struct json_object* j_runnable = nullptr;
+ int retry = 0;
+ do {
+ if(afmmain->runnables(api, &j_runnable) == 0) {
+ createAppDetailList(j_runnable);
+ json_object_put(j_runnable);
+ break;
+ }
+
+ ++retry;
+ if(retry == RETRY_CNT) {
+ HMI_ERROR("homescreen-service","get runnables list failed");
+ json_object_put(j_runnable);
+ return -1;
+ }
+ HMI_NOTICE("homescreen-service","retry to get runnables list %d", retry);
+ usleep(100000); // 100ms
+ } while(1);
+
+ return 0;
+}
+
+/**
+ * onEvent function
+ *
+ * #### Parameters
+ * - api : the api serving the request
+ * - event : event name
+ * - object : event json object
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_AppInfo::onEvent(afb_api_t api, const char *event, struct json_object *object)
+{
+ auto ip = concerned_event_list.find(std::string(event));
+ if(ip != concerned_event_list.end()) {
+ HMI_NOTICE("homescreen-service","[%s] event received.", event);
+ (this->*(ip->second))(api, object);
+ }
+}
+
+/**
+ * create application detail list function
+ *
+ * #### Parameters
+ * - object : the detail of all applications
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_AppInfo::createAppDetailList(struct json_object *object)
+{
+ HMI_NOTICE("homescreen-service","applist:%s", json_object_to_json_string(object));
+
+ if(json_object_get_type(object) == json_type_array) {
+ int array_len = json_object_array_length(object);
+ for (int i = 0; i < array_len; ++i) {
+ struct json_object *obj = json_object_array_get_idx(object, i);
+ addAppDetail(obj);
+ }
+ }
+ else {
+ HMI_ERROR("homescreen-service","Apps information input error.");
+ }
+}
+
+/**
+ * update application detail function
+ *
+ * #### Parameters
+ * - object : the detail of all applications
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_AppInfo::updateAppDetailList(afb_api_t api, struct json_object *object)
+{
+ HMI_NOTICE("homescreen-service","update:%s", json_object_to_json_string(object));
+ if(json_object_get_type(object) != json_type_object) {
+ HMI_ERROR("homescreen-service","input detail object error.");
+ return;
+ }
+
+ struct json_object *obj_oper, *obj_data;
+ if(json_object_object_get_ex(object, _keyOperation, &obj_oper) == 0
+ || json_object_object_get_ex(object, _keyData, &obj_data) == 0) {
+ HMI_ERROR("homescreen-service","can't find key=%s, %s.", _keyOperation, _keyData);
+ return;
+ }
+
+ std::string id = json_object_get_string(obj_data);
+ std::string appid = id2appid(id);
+ if(isPeripheryApp(appid.c_str())) {
+ HMI_NOTICE("homescreen-service", "install/uninstall application is periphery.");
+ return;
+ }
+
+ std::string oper = json_object_get_string(obj_oper);
+ if(oper == _keyInstall) {
+ struct json_object* j_runnable = nullptr;
+ int ret = afmmain->runnables(api, &j_runnable);
+ if(!ret) {
+ struct json_object *j_found = retrieveRunnables(j_runnable, id);
+ if(j_found == nullptr) {
+ HMI_NOTICE("homescreen-service", "installed application isn't runnables.");
+ json_object_put(j_runnable);
+ return;
+ }
+ addAppDetail(j_found);
+ pushAppListChangedEvent(_keyInstall, j_found);
+ }
+ else {
+ HMI_ERROR("homescreen-service","get runnalbes failed.");
+ }
+ json_object_put(j_runnable);
+ }
+ else if(oper == _keyUninstall) {
+ std::string appid_checked = checkAppId(appid);
+ if(appid_checked.empty()) {
+ HMI_NOTICE("homescreen-service","uninstalled application isn't in runnables list, appid=%s.", appid.c_str());
+ return;
+ }
+ pushAppListChangedEvent(_keyUninstall, obj_data);
+ removeAppDetail(appid);
+ }
+ else {
+ HMI_ERROR("homescreen-service","operation error.");
+ }
+}
+
+/**
+ * parse application detail function
+ *
+ * #### Parameters
+ * - object : [IN] the detail of application
+ * - info : [OUT] parsed application detail
+ *
+ * #### Return
+ * the appid of application liked "dashboard"
+ *
+ */
+std::string HS_AppInfo::parseAppDetail(struct json_object *object, AppDetail &info) const
+{
+ struct json_object *name, *id;
+ if(json_object_object_get_ex(object, _keyName, &name) == 0
+ || json_object_object_get_ex(object, _keyId, &id) == 0) {
+ HMI_ERROR("homescreen-service","can't find key=%s, %s.", _keyName, _keyId);
+ return std::string();
+ }
+ std::string appid = id2appid(json_object_get_string(id));
+ bool periphery = isPeripheryApp(appid.c_str());
+
+ info = { json_object_get_string(name),
+ json_object_get_string(id),
+ json_object_to_json_string(object),
+ periphery
+ };
+ return appid;
+}
+
+/**
+ * add application detail to list function
+ *
+ * #### Parameters
+ * - object : application detail
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_AppInfo::addAppDetail(struct json_object *object)
+{
+ AppDetail info;
+ std::string appid = parseAppDetail(object, info);
+ if(appid.empty()) {
+ HMI_ERROR("homescreen-service","application id error");
+ return;
+ }
+
+ std::lock_guard<std::mutex> lock(this->mtx);
+ appid2name[appid] = info.name;
+ name2appid[info.name] = appid;
+ app_detail_list[appid] = std::move(info);
+}
+
+/**
+ * remove application detail from list function
+ *
+ * #### Parameters
+ * - appid : application id
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_AppInfo::removeAppDetail(std::string appid)
+{
+ std::lock_guard<std::mutex> lock(this->mtx);
+ auto it = app_detail_list.find(appid);
+ if(it != app_detail_list.end()) {
+ appid2name.erase(appid);
+ name2appid.erase(it->second.name);
+ app_detail_list.erase(it);
+ }
+ else {
+ HMI_WARNING("homescreen-service","erase application(%s) wasn't in applist.", appid.c_str());
+ }
+}
+
+/**
+ * push app_list_changed event function
+ *
+ * #### Parameters
+ * - oper: install/uninstall
+ * - object: event data
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_AppInfo::pushAppListChangedEvent(const char *oper, struct json_object *object)
+{
+ HMI_NOTICE("homescreen-service","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);
+
+ HS_ClientManager::instance()->pushEvent(_keyApplistChanged, push_obj);
+}
+
+/**
+ * retrieve runnables function
+ *
+ * #### Parameters
+ * - obj_runnables: runnables array
+ * - id: application id
+ *
+ * #### Return
+ * found application detail
+ *
+ */
+struct json_object* HS_AppInfo::retrieveRunnables(struct json_object *obj_runnables, std::string id)
+{
+ struct json_object *j_found = nullptr;
+ if(json_object_get_type(obj_runnables) == json_type_array) {
+ int array_len = json_object_array_length(obj_runnables);
+ for (int i = 0; i < array_len; ++i) {
+ struct json_object *obj = json_object_array_get_idx(obj_runnables, i);
+ struct json_object *j_id;
+ if(json_object_object_get_ex(obj, _keyId, &j_id) == 0) {
+ HMI_WARNING("homescreen-service","can't find id.");
+ continue;
+ }
+ if(id == json_object_get_string(j_id)) {
+ j_found = obj;
+ break;
+ }
+ }
+ }
+ else {
+ HMI_ERROR("homescreen-service","Apps information input error.");
+ }
+ return j_found;
+}
+
+/**
+ * convert id to appid function
+ *
+ * #### Parameters
+ * - id : the id of application liked "dashboard@0.1"
+ *
+ * #### Return
+ * the appid of application liked "dashboard"
+ *
+ */
+std::string HS_AppInfo::id2appid(const std::string &id) const
+{
+ std::string appid;
+ std::size_t pos = id.find("@");
+ if(pos != std::string::npos) {
+ appid = id.substr(0,pos);
+ }
+ else {
+ HMI_ERROR("homescreen-service","input id error.");
+ }
+ return appid;
+}
+
+/**
+ * get runnables list
+ *
+ * #### Parameters
+ * - object : runnables list,json array
+ *
+ * #### Return
+ * None
+ *
+ */
+void HS_AppInfo::getRunnables(struct json_object **object)
+{
+ if(json_object_get_type(*object) != json_type_array) {
+ HMI_ERROR("homescreen-service","json type error.");
+ return;
+ }
+
+ std::lock_guard<std::mutex> lock(this->mtx);
+ for(auto it : app_detail_list) {
+ if(!it.second.periphery)
+ json_object_array_add(*object, json_tokener_parse(it.second.detail.c_str()));
+ }
+}
+
+/**
+ * check appid function
+ *
+ * #### Parameters
+ * - appid : appid liked "dashboard"
+ *
+ * #### Return
+ * success : the correct appid
+ * fail : empty string
+ *
+ */
+std::string HS_AppInfo::checkAppId(const std::string &appid)
+{
+ std::lock_guard<std::mutex> lock(this->mtx);
+ auto it_appid = appid2name.find(appid);
+ if(it_appid != appid2name.end())
+ return it_appid->first;
+
+ auto it_name = name2appid.find(appid);
+ if(it_name != name2appid.end())
+ return it_name->second;
+
+ return std::string();
+}
+
+/**
+ * check if application is a runnable periphery application function
+ *
+ * #### Parameters
+ * - appid : appid liked "launcher"
+ *
+ * #### Return
+ * true : periphery
+ * false : not periphery
+ *
+ */
+bool HS_AppInfo::isPeripheryApp(const char *appid) const
+{
+ bool ret = false;
+ for(auto m : periphery_app_list) {
+ if(strcasecmp(appid, m) == 0) {
+ ret = true;
+ break;
+ }
+ }
+ return ret;
+}
+
+/**
+ * get application specific property
+ *
+ * #### Parameters
+ * - appid : appid liked "launcher"
+ * - key : the keyword
+ *
+ * #### Return
+ * application property
+ *
+ */
+std::string HS_AppInfo::getAppProperty(const std::string appid, std::string key) const
+{
+ std::string value = "";
+ auto it = app_detail_list.find(appid);
+ if(it != app_detail_list.end()) {
+ value = it->second.getProperty(key);
+ }
+ return value;
+} \ No newline at end of file