2 * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
22 #include <app_control.h>
23 #include <app_manager.h>
24 #include <cynara-client.h>
25 #include <cynara-error.h>
26 #include <cynara-session.h>
28 #include "gestured_dbus.h"
29 #include "gestured_error.h"
30 #include "gesture_defs.h"
31 #include "gestured_client_manager.h"
32 #include "gestured_engine_manager.h"
33 #include "gestured_invocation_manager.h"
38 #define LOG_TAG "GESTURED_SERVER_DBUS"
40 #define GESTURE_DIRECTORY tzplatform_mkpath(TZ_SYS_SHARE, "gesture-data")
41 #define MAX_ERROR_BUFFER 256
43 static GHashTable *_monitoring_hash;
46 static GDBusConnection *_gdbus_connection;
47 static const char *_client_bus_name;
48 static const char *_engine_bus_name;
51 static bool __is_engine_installed(const char* appid);
52 static bool __is_engine_launched(const char* appid);
55 static cynara *p_cynara = NULL;
56 static int _cynara_initialize()
58 int ret = cynara_initialize(&p_cynara, NULL);
59 if (ret != CYNARA_API_SUCCESS)
60 LOGE("Failed to cynara initialize");
65 static int _check_privilege(const char *uid, const int pid, const char *label, const char *privilege)
73 char *session = cynara_session_from_pid(pid);
74 ret = cynara_check(p_cynara, label, session, uid, privilege);
77 if (ret != CYNARA_API_ACCESS_ALLOWED) {
78 LOGE("Access denied. The result of cynara_check() : %d.", ret);
85 static void _cynara_deinitialize()
88 cynara_finish(p_cynara);
93 static int _gesture_check_privilege(const char *uid, const int pid, const char *label)
95 int ret = GESTURED_ERROR_NONE;
97 if (_cynara_initialize() != CYNARA_API_SUCCESS)
98 return GESTURED_ERROR_PERMISSION_DENIED;
100 if (_check_privilege(uid, pid, label, GESTURE_PRIVILEGE_APPLAUNCH) < 0) {
101 LOGE("Permission is denied");
102 ret = GESTURED_ERROR_PERMISSION_DENIED;
105 _cynara_deinitialize();
112 int gestured_server_register(GVariant *parameters, GVariant **reply_body, const gchar *sender, GBusNameAppearedCallback name_appeared_handler,
113 GBusNameVanishedCallback name_vanished_handler, GHashTable **monitoring_hash)
115 LOGD("server_dbus : gestured_server_register start");
117 const char *bus_name = sender;
118 monitoring_info_s *m_info = NULL;
119 uid_t request_uid = 0;
120 CLIENT_LIB clientLib;
121 char *pkgName = NULL;
123 char *client_uid = NULL;
124 char *client_smack_label = NULL;
126 if (bus_name == NULL)
127 return GESTURED_ERROR_IO_ERROR;
129 g_variant_get(parameters, "(iisiss)", &request_uid, &clientLib, &pkgName, &client_pid, &client_uid, &client_smack_label);
130 LOGD("gestured_server_register > request_uid: %d", request_uid);
131 LOGD("gestured_server_register > clientLib: %d", clientLib);
132 LOGD("gestured_server_register > pkgName: %s", pkgName);
133 LOGD("gestured_server_register > client_pid: %d", client_pid);
134 LOGD("gestured_server_register > client_uid: %s", (NULL == client_uid) ? "NULL" : client_uid);
135 LOGD("gestured_server_register > client_smack_label: %s", (NULL == client_smack_label) ? "NULL" : client_smack_label);
137 if (clientLib == GESTURE_CLIENT_LIB_ENGINE) {
138 _engine_bus_name = g_strdup(bus_name);
139 } else if (clientLib == GESTURE_CLIENT_LIB_GESTURE) {
140 _client_bus_name = g_strdup(bus_name);
143 if (clientLib == GESTURE_CLIENT_LIB_GESTURE) {
144 /* check privilege */
145 if (GESTURED_ERROR_NONE != _gesture_check_privilege(client_uid, client_pid, client_smack_label)) {
146 LOGE("[ERROR] Permission denied");
148 return GESTURED_ERROR_PERMISSION_DENIED;
150 LOGI("[INFO] Permission allowed");
153 /* launch engine process if engine is not running */
154 bool is_launched = __is_engine_launched("org.tizen.gesture-engine-default");
155 if (false == is_launched) {
156 LOGI("Request to launch engine");
157 __launch_engine_service_app("org.tizen.gesture-engine-default");
159 LOGI("engine is launched");
162 /* Check this client is already registerd to server or not */
163 bool already_registered = GestureManagerClientAlreadyRegisterd(bus_name);
164 if (already_registered) {
165 LOGD("This client is skipped to register because already registerd to server");
166 return GESTURED_ERROR_NONE;
169 /* create a new client data */
170 gesture_manager_client_s* client = NULL;
171 client = GestureManagerClientCreate(pkgName);
172 if (NULL == client) {
173 LOGE("Fail to create a new client");
174 return GESTURED_ERROR_OPERATION_FAILED;
176 client->is_permitted = true;
177 client->clientLib = clientLib;
178 client->request_uid = request_uid;
179 client->gdbus_bus_name = strdup(bus_name);
180 client->gdbus_watch_id = g_bus_watch_name_on_connection(
183 G_BUS_NAME_WATCHER_FLAGS_NONE,
184 name_appeared_handler,
185 name_vanished_handler,
188 if (client->gdbus_watch_id == 0) {
189 LOGE("Failed to get identifier");
190 GestureManagerClientDestroy(client);
191 return GESTURED_ERROR_OPERATION_FAILED;
194 int ret = GestureManagerClientAdd(client);
195 if (ret != HAND_GESTURE_ERROR_NONE) {
196 LOGE("Failed to add client to GestureManager");
197 return GESTURED_ERROR_OPERATION_FAILED;
200 LOGD("GestureManager Client count = %d", GestureManagerClientNums());
201 } else if (clientLib == GESTURE_CLIENT_LIB_ENGINE) {
202 /* Check this engine is already registerd to server or not */
203 bool already_registered = GestureManagerEngineAlreadyRegisterd(bus_name);
204 if (already_registered) {
205 LOGD("This engine is skipped to register because already registerd to server");
206 return GESTURED_ERROR_NONE;
209 /* create a new engine data */
210 gesture_manager_engine_s* engine = NULL;
211 engine = GestureManagerEngineCreate(pkgName);
212 if (NULL == engine) {
213 LOGE("Fail to create a new engine");
214 return GESTURED_ERROR_OPERATION_FAILED;
216 engine->clientLib = clientLib;
217 engine->request_uid = request_uid;
218 engine->gdbus_bus_name = strdup(bus_name);
219 engine->gdbus_watch_id = g_bus_watch_name_on_connection(
222 G_BUS_NAME_WATCHER_FLAGS_NONE,
223 name_appeared_handler,
224 name_vanished_handler,
227 if (engine->gdbus_watch_id == 0) {
228 LOGE("Failed to get identifier");
229 GestureManagerEngineDestroy(engine);
230 return GESTURED_ERROR_OPERATION_FAILED;
233 int ret = GestureManagerEngineAdd(engine);
234 if (ret != HAND_GESTURE_ERROR_NONE) {
235 LOGE("Failed to add engine to GestureManager");
236 return GESTURED_ERROR_OPERATION_FAILED;
238 LOGD("GestureManager Engine count = %d", GestureManagerEngineNums());
241 LOGE("Error type : CLIENT_LIB must be GESTURE_CLIENT_LIB_GESTURE or GESTURE_CLIENT_LIB_ENGINE");
242 return GESTURED_ERROR_OPERATION_FAILED;
245 return GESTURED_ERROR_NONE;
248 int gestured_server_register_dbus_interface(char *introspection_xml, GDBusInterfaceVTable interface_vtable)
250 LOGD("server_dbus : gestured_server_register_dbus_interface start");
253 int own_id, registration_id;
254 GError *error = NULL;
255 GDBusNodeInfo *introspection_data = NULL;
257 if (_gdbus_connection == NULL) {
258 _gdbus_connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
259 if (_gdbus_connection == NULL) {
261 LOGE("g_bus_get_sync error message = %s", error->message);
264 result = GESTURED_ERROR_IO_ERROR;
269 own_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
271 G_BUS_NAME_OWNER_FLAGS_NONE,
277 LOGE("Failed to register bus name");
278 result = GESTURED_ERROR_IO_ERROR;
282 LOGD("own_id = %d", own_id);
284 introspection_data = g_dbus_node_info_new_for_xml(introspection_xml, &error);
285 if (introspection_data == NULL) {
286 LOGE("Failed to get GDBusNodeInfo");
287 result = GESTURED_ERROR_IO_ERROR;
289 LOGE("g_dbus_node_info_new_for_xml error message = %s", error->message);
295 registration_id = g_dbus_connection_register_object(_gdbus_connection, GESTURE_OBJECT_PATH,
296 introspection_data->interfaces[0], &interface_vtable, NULL, NULL, NULL);
297 LOGD("registration_id = %d", registration_id);
298 if (registration_id == 0) {
299 LOGE("Failed to register object");
300 result = GESTURED_ERROR_IO_ERROR;
304 gestureInvocationManagerInit();
306 return GESTURED_ERROR_NONE;
309 if (introspection_data)
310 g_dbus_node_info_unref(introspection_data);
315 int delete_monitoring_list(GHashTable **monitoring_hash, const char *sender, uid_t uid)
317 LOGD("server_dbus : delete_monitoring_list start");
318 int ret = GESTURED_ERROR_NONE;
320 gesture_manager_client_s *client = NULL;
321 client = GestureManagerClientGet(sender);
323 LOGD("failed to GestureManagerClientGet");
324 return GESTURED_ERROR_OPERATION_FAILED;
326 ret = GestureManagerClientRemove(client);
327 if (ret != GESTURED_ERROR_NONE) {
328 LOGE("Fail to remove client");
332 return GESTURED_ERROR_NONE;
335 int gestured_send_dbus_message(GVariant *body, const char *sender, char *cmd, CLIENT_LIB lib)
337 LOGD("server_dbus : gestured_send_dbus_message [sender = %s] [cmd = %s]", sender, cmd);
340 char *interface = NULL;
341 const char *bus_name = NULL;
343 if (lib == GESTURE_CLIENT_LIB_ENGINE) {
344 interface = GESTURE_ENGINE_INTERFACE_NAME;
345 bus_name = _engine_bus_name;
346 } else if (lib == GESTURE_CLIENT_LIB_GESTURE) {
347 interface = GESTURE_CLIENT_INTERFACE_NAME;
348 bus_name = _client_bus_name;
351 char *printmsg = g_variant_print(body, true);
352 LOGD("send_dbus_msg body print : %s", printmsg);
354 LOGD("[_client_bus_name = %s] [_engine_bus_name = %s]", _client_bus_name, _engine_bus_name);
355 LOGD("send message server to clinet/engine : bus_name = %s", bus_name);
357 if (g_variant_is_floating(body))
360 int num = GestureManagerClientNums();
361 if (lib == GESTURE_CLIENT_LIB_GESTURE && !strncmp(cmd, GESTURE_CLIENT_SIGNAL_GET_RESULT, strlen(cmd)) && num > 1) {
362 for (int i = 0; i < num; i++) {
363 bus_name = GestureManagerClientGetBusName(i);
365 gesture_manager_client_s *client = GestureManagerClientGetWithBusName(bus_name);
366 LOGD("==========================");
367 LOGD("client num = %d", num);
368 LOGD("client pkg = %s", client->pkg_name);
369 LOGD("current i = %d", i);
370 LOGD("bus name = %s", bus_name);
371 LOGD("interface = %s", interface);
372 LOGD("cmd = %s", cmd);
373 LOGD("==========================");
375 if (!g_dbus_connection_emit_signal(_gdbus_connection,
383 LOGE("Failed to send dbus message : %s", err->message);
387 return GESTURED_ERROR_IO_ERROR;
391 if (!g_dbus_connection_emit_signal(_gdbus_connection,
399 LOGE("Failed to send dbus message : %s", err->message);
403 return GESTURED_ERROR_IO_ERROR;
406 return GESTURED_ERROR_NONE;
409 static void _on_name_appeared(GDBusConnection *connection,
411 const gchar *name_owner,
414 LOGD("[name: %s] [name_owner: %s]", name, name_owner);
417 static void _on_name_vanished(GDBusConnection *connection,
421 gesture_manager_client_s *client = NULL;
422 client = GestureManagerClientGetWithBusName(name);
424 LOGD("failed to GestureManagerClientGetWithBusName");
426 int ret = GestureManagerClientRemove(client);
427 if (ret != GESTURED_ERROR_NONE) {
428 LOGE("Fail to remove client");
430 LOGD("GestureManager Client count = %d", GestureManagerClientNums());
432 gesture_manager_engine_s *engine = NULL;
433 engine = GestureManagerEngineGetWithBusName(name);
435 LOGD("failed to GestureManagerEngineGetWithBusName");
437 ret = GestureManagerEngineRemove(engine);
438 if (ret != GESTURED_ERROR_NONE) {
439 LOGE("Fail to remove engine");
441 LOGD("GestureManager Engine count = %d", GestureManagerEngineNums());
444 static void _gestured_client_dbus_method_call_handler(GDBusConnection *conn, const gchar *sender, const gchar *object_path,
445 const gchar *iface_name, const gchar *method_name, GVariant *parameters, GDBusMethodInvocation *invocation,
448 LOGD("gestured [sender: %s], [object_path: %s]", sender, object_path);
449 LOGD("gestured [iface_name: %s], [method_name: %s]", iface_name, method_name);
450 LOGD("gestured _monitoring_hash len: %d", g_hash_table_size(_monitoring_hash));
452 GVariant *reply_body = NULL;
453 int ret = GESTURED_ERROR_NONE;
454 bool delay_response = false;
456 if (g_strcmp0(method_name, GESTURE_MSG_SERVICE_REGISTER) == 0) {
457 LOGD("[GESTURE_MSG_SERVICE_REGISTER] called");
458 ret = gestured_server_register(parameters, &reply_body, sender,
459 _on_name_appeared, _on_name_vanished, &_monitoring_hash);
462 else if (g_strcmp0(method_name, GESTURE_CLIENT_MSG_INITIALIZE_ENGINE) == 0) {
463 LOGD("[GESTURE_CLIENT_MSG_INITIALIZE_ENGINE] called");
464 ret = gestured_client_initialize_engine(parameters, &reply_body, sender);
466 else if (g_strcmp0(method_name, GESTURE_CLIENT_MSG_DEINITIALIZE_ENGINE) == 0) {
467 LOGD("[GESTURE_CLIENT_MSG_DEINITIALIZE_ENGINE] called");
468 ret = gestured_client_deinitialize_engine(parameters, &reply_body, sender);
470 else if (g_strcmp0(method_name, GESTURE_CLIENT_MSG_START_RECOGNITION) == 0) {
471 LOGD("[GESTURE_CLIENT_MSG_START_RECOGNITION] called");
472 ret = gestured_client_start_recognition(parameters, &reply_body, sender);
474 else if (g_strcmp0(method_name, GESTURE_CLIENT_MSG_STOP_RECOGNITION) == 0) {
475 LOGD("[GESTURE_CLIENT_MSG_STOP_RECOGNITION] called");
476 ret = gestured_client_stop_recognition(parameters, &reply_body, sender);
478 else if (g_strcmp0(method_name, GESTURE_CLIENT_MSG_FOREACH_RESULT_TIME) == 0) {
479 LOGD("[GESTURE_CLIENT_MSG_FOREACH_RESULT_TIME] called");
480 ret = gestured_client_foreach_result_time(parameters, &reply_body, sender);
482 else if (g_strcmp0(method_name, GESTURE_CLIENT_MSG_FOREACH_SUPPORTED_TYPE) == 0) {
483 LOGD("[GESTURE_CLIENT_MSG_FOREACH_SUPPORTED_TYPE] called");
484 ret = gestured_client_foreach_supported_type(parameters, &reply_body, sender);
486 else if (g_strcmp0(method_name, GESTURE_CLIENT_MSG_IS_SUPPORT_GESTURE_TYPE) == 0) {
487 LOGD("[GESTURE_CLIENT_MSG_IS_SUPPORT_GESTURE_TYPE] called");
488 ret = gestured_client_is_support_gesture_type(parameters, &reply_body, sender, invocation);
489 delay_response = true;
491 else if (g_strcmp0(method_name, GESTURE_CLIENT_MSG_ENGINE_GET_INFO) == 0) {
492 LOGD("[GESTURE_CLIENT_MSG_ENGINE_GET_INFO] called");
493 ret = gestured_client_get_engine_info(parameters, &reply_body, sender, invocation);
494 delay_response = true;
498 else if (g_strcmp0(method_name, GESTURE_ENGINE_MSG_SEND_RESULT) == 0) {
499 LOGD("[GESTURE_ENGINE_MSG_SEND_RESULT] called");
500 ret = gestured_engine_send_result(parameters, &reply_body, sender);
502 else if (g_strcmp0(method_name, GESTURE_ENGINE_MSG_SEND_ERROR) == 0) {
503 LOGD("[GESTURE_ENGINE_MSG_SEND_ERROR] called");
504 ret = gestured_engine_send_error(parameters, &reply_body, sender);
506 else if (g_strcmp0(method_name, GESTURE_ENGINE_MSG_SEND_MOTION_STATUS) == 0) {
507 LOGD("[GESTURE_ENGINE_MSG_SEND_MOTION_STATUS] called");
508 ret = gestured_engine_send_motion_status(parameters, &reply_body, sender);
510 else if (g_strcmp0(method_name, GESTURE_ENGINE_MSG_MAIN_START) == 0) {
511 LOGD("[GESTURE_ENGINE_MSG_MAIN_START] called");
513 else if (g_strcmp0(method_name, GESTURE_ENGINE_MSG_GET_ENGINE_INFO) == 0) {
514 LOGD("[GESTURE_ENGINE_MSG_GET_ENGINE_INFO] called");
519 g_variant_get(parameters, "(iss)", &id, &app_id, &name);
520 ret = gestured_reply_get_engine_info(id, app_id, name);
522 else if (g_strcmp0(method_name, GESTURE_ENGINE_MSG_IS_SUPPORT_GESTURE_TYPE) == 0) {
523 LOGD("[GESTURE_ENGINE_MSG_IS_SUPPORT_GESTURE_TYPE] called");
525 bool is_supported = false;
527 g_variant_get(parameters, "(ib)", &id, &is_supported);
528 ret = gestured_reply_is_support_gesture_type(id, is_supported);
531 if (false == delay_response) {
532 if (ret == GESTURED_ERROR_NONE) {
533 LOGD("method_call successful, method_name : %s", method_name);
534 g_dbus_method_invocation_return_value(invocation, reply_body);
536 LOGE("method_call failed, method_name : %s", method_name);
537 g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, ret, "gesture error");
542 g_variant_unref(reply_body);
545 static const GDBusInterfaceVTable _gesture_interface_vtable = {
546 _gestured_client_dbus_method_call_handler,
551 int gestured_register_dbus_interface(void)
553 LOGD("gestured_register_dbus_interface");
555 FILE* xml_file = NULL;
556 char xml_file_path[256] = {'\0', };
557 char* introspection_xml = NULL;
561 snprintf(xml_file_path, 256, "%s/capi-ui-gesture-gdbus.xml", GESTURE_SHARED_RESOURCE_PATH);
562 ret = access(xml_file_path, R_OK);
564 LOGE("Introspection file is not exist. path(%s)", xml_file_path);
565 return GESTURED_ERROR_OPERATION_FAILED;
568 xml_file = fopen(xml_file_path, "r");
569 if (NULL == xml_file) {
570 LOGE("Fail to open introspection file");
571 return GESTURED_ERROR_OPERATION_FAILED;
574 fseek(xml_file, 0, SEEK_END);
575 size = ftell(xml_file);
578 introspection_xml = (char*)calloc(sizeof(char), size);
579 if (NULL == introspection_xml) {
580 LOGE("Fail to allocate memory");
582 return GESTURED_ERROR_OUT_OF_MEMORY;
585 ret = fread(introspection_xml, 1, size, xml_file);
587 LOGE("Error is occured reading file");
589 free(introspection_xml);
590 return GESTURED_ERROR_OPERATION_FAILED;
593 ret = gestured_server_register_dbus_interface(introspection_xml, _gesture_interface_vtable);
596 free(introspection_xml);
601 int gestured_dbus_init(void)
603 LOGD("gestured_dbus_init");
606 ret = gestured_register_dbus_interface();
607 if (ret != GESTURED_ERROR_NONE) {
608 LOGE("Failed to register dbus interface : %d", ret);
609 return GESTURED_ERROR_OPERATION_FAILED;
612 return GESTURED_ERROR_NONE;
615 /*******************************************/
616 /* client side function : client -> daemon */
617 /* must add logic to send dameon -> engine */
618 /*******************************************/
620 int gestured_client_initialize_engine(GVariant *parameters, GVariant **reply_body, const char *sender)
622 int ret = GESTURED_ERROR_NONE;
623 char *cmd = GESTURE_ENGINE_SIGNAL_ENGINE_INITIALIZE;
625 if (parameters == NULL) {
626 LOGE("failed to get parameters");
627 return GESTURED_ERROR_INVALID_PARAMETER;
630 /* check privilege */
631 gesture_manager_client_s *client = GestureManagerClientGetWithBusName(sender);
633 LOGE("failed to GestureManagerClientGet");
634 return GESTURED_ERROR_OPERATION_FAILED;
637 if (false == client->is_permitted) {
638 LOGE("[ERROR] Permission denied");
639 return GESTURED_ERROR_PERMISSION_DENIED;
642 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_ENGINE);
643 if (ret != GESTURED_ERROR_NONE)
644 LOGE("Failed to start to engine");
649 int gestured_client_deinitialize_engine(GVariant *parameters, GVariant **reply_body, const char *sender)
651 int ret = GESTURED_ERROR_NONE;
652 char *cmd = GESTURE_ENGINE_SIGNAL_ENGINE_DEINITIALIZE;
654 if (parameters == NULL) {
655 LOGE("failed to get parameters");
656 return GESTURED_ERROR_INVALID_PARAMETER;
659 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_ENGINE);
660 if (ret != GESTURED_ERROR_NONE)
661 LOGE("Failed to start to engine");
666 int gestured_client_start_recognition(GVariant *parameters, GVariant **reply_body, const char *sender)
668 LOGD("gestured_client_start_recognition : sendor [%s]", sender);
670 int ret = GESTURED_ERROR_NONE;
671 char *cmd = GESTURE_ENGINE_SIGNAL_ENGINE_START;
673 if (parameters == NULL) {
674 LOGE("failed to get parameters");
675 return GESTURED_ERROR_INVALID_PARAMETER;
678 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_ENGINE);
679 if (ret != GESTURED_ERROR_NONE) {
680 LOGE("Failed to start to engine");
681 return GESTURED_ERROR_OPERATION_FAILED;
687 int gestured_client_stop_recognition(GVariant *parameters, GVariant **reply_body, const char *sender)
689 LOGE("gestured_client_stop_recognition : sendor [%s]", sender);
691 int ret = GESTURED_ERROR_NONE;
692 char *cmd = GESTURE_ENGINE_SIGNAL_ENGINE_STOP;
694 if (parameters == NULL) {
695 LOGE("failed to get parameters");
696 return GESTURED_ERROR_INVALID_PARAMETER;
699 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_ENGINE);
700 if (ret != GESTURED_ERROR_NONE) {
701 LOGE("Failed to start to engine");
707 int gestured_client_foreach_result_time(GVariant *parameters, GVariant **reply_body, const char *sender)
709 int ret = GESTURED_ERROR_NONE;
710 char *cmd = GESTURE_ENGINE_SIGNAL_FOREACH_RESULT_TIME;
712 if (parameters == NULL) {
713 LOGE("failed to get parameters");
714 return GESTURED_ERROR_INVALID_PARAMETER;
717 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_ENGINE);
718 if (ret != GESTURED_ERROR_NONE)
719 LOGE("Failed to start to engine");
724 int gestured_client_foreach_supported_type(GVariant *parameters, GVariant **reply_body, const char *sender)
726 int ret = GESTURED_ERROR_NONE;
727 char *cmd = GESTURE_ENGINE_SIGNAL_FOREACH_SUPPORTED_TYPE;
729 if (parameters == NULL) {
730 LOGE("failed to get parameters");
731 return GESTURED_ERROR_INVALID_PARAMETER;
734 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_ENGINE);
735 if (ret != GESTURED_ERROR_NONE)
736 LOGE("Failed to start to engine");
741 int gestured_client_is_support_gesture_type(GVariant *parameters, GVariant **reply_body, const char *sender, GDBusMethodInvocation* invocation)
743 int ret = GESTURED_ERROR_NONE;
744 char *cmd = GESTURE_ENGINE_SIGNAL_IS_SUPPORT_GESTURE_TYPE;
746 if (parameters == NULL) {
747 LOGE("failed to get parameters");
748 return GESTURED_ERROR_INVALID_PARAMETER;
751 int id = gestureInvocationManagerAdd(invocation);
753 LOGE("Fail to store invocation");
754 return GESTURED_ERROR_OPERATION_FAILED;
757 int gesture_type = 0;
758 g_variant_get(parameters, "(i)", &gesture_type);
760 LOGD("invocation id (%d), gesture type(%d)", id, gesture_type);
761 GVariant* body = g_variant_new("(ii)", id, gesture_type);
763 LOGE("Fail to create body");
764 return GESTURED_ERROR_OPERATION_FAILED;
767 ret = gestured_send_dbus_message(body, sender, cmd, GESTURE_CLIENT_LIB_ENGINE);
768 if (ret != GESTURED_ERROR_NONE)
769 LOGE("Failed to start to engine");
774 int gestured_client_get_engine_info(GVariant *parameters, GVariant **reply_body, const char *sender, GDBusMethodInvocation* invocation)
776 LOGD("[engineInfo] gestured_client_get_engine_info : sendor [%s]", sender);
778 int ret = GESTURED_ERROR_NONE;
779 char *cmd = GESTURE_ENGINE_SIGNAL_GET_ENGINE_INFO;
781 if (parameters == NULL) {
782 LOGE("failed to get parameters");
783 return GESTURED_ERROR_INVALID_PARAMETER;
786 int id = gestureInvocationManagerAdd(invocation);
788 LOGE("Fail to store invocation");
789 return GESTURED_ERROR_OPERATION_FAILED;
792 LOGD("invocation ID (%d)", id);
793 GVariant* body = g_variant_new("(i)", id);
795 LOGE("Fail to create body");
796 return GESTURED_ERROR_OPERATION_FAILED;
799 ret = gestured_send_dbus_message(body, sender, cmd, GESTURE_CLIENT_LIB_ENGINE);
800 if (ret != GESTURED_ERROR_NONE)
801 LOGE("Failed to start to engine");
806 /*******************************************/
807 /* engine side function : engine -> daemon */
808 /* must add logic to send dameon -> client */
809 /*******************************************/
811 int gestured_engine_send_result(GVariant *parameters, GVariant **reply_body, const char *sender)
813 LOGD("gestured_engine_send_result : sendor [%s]", sender);
815 int event, gesture_type, ltype, levent, lcount;
816 g_variant_get(parameters, "(iiiii)", &event, &gesture_type, <ype, &levent, &lcount);
817 LOGD("[event = %d] [gesture_type = %d] [ltype = %d] [levent = %d] [lcount = %d]", event, gesture_type, ltype, levent, lcount);
819 int ret = GESTURED_ERROR_NONE;
820 char *cmd = GESTURE_CLIENT_SIGNAL_GET_RESULT;
821 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_GESTURE);
825 int gestured_engine_send_error(GVariant *parameters, GVariant **reply_body, const char *sender)
827 LOGE("gestured_engine_send_error : sendor [%s]", sender);
829 int ret = GESTURED_ERROR_NONE;
830 char *cmd = GESTURE_CLIENT_SIGNAL_GET_ERROR;
831 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_GESTURE);
835 int gestured_engine_send_motion_status(GVariant *parameters, GVariant **reply_body, const char *sender)
837 LOGE("gestured_engine_send_motion_status : sendor [%s]", sender);
839 int ret = GESTURED_ERROR_NONE;
840 char *cmd = GESTURE_CLIENT_SIGNAL_GET_MOTION_STATUS;
841 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_GESTURE);
845 int gestured_engine_send_engine_get_info(GVariant *parameters, GVariant **reply_body, const char *sender)
847 LOGD("[engineInfo] gestured_engine_send_engine_get_info : sendor [%s]", sender);
849 int ret = GESTURED_ERROR_NONE;
850 char *cmd = GESTURE_CLIENT_SIGNAL_GET_ENGINE_INFO;
851 ret = gestured_send_dbus_message(parameters, sender, cmd, GESTURE_CLIENT_LIB_GESTURE);
855 int gestured_reply_is_support_gesture_type(int invocation_id, bool is_supported)
857 GDBusMethodInvocation *invocation = gestureInvocationManagerGet(invocation_id);
858 if (NULL == invocation) {
859 LOGE("Invalid invocation ID");
860 return GESTURED_ERROR_INVALID_PARAMETER;
862 gestureInvocationManagerRemove(invocation_id);
864 GVariant *reply_body = g_variant_new("(b)", is_supported);
865 if (NULL == reply_body) {
866 LOGE("Fail to create reply_body");
867 g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, GESTURED_ERROR_OPERATION_FAILED, "Fail to create return value");
868 return GESTURED_ERROR_OPERATION_FAILED;
871 LOGD("Invocation ID(%d), IsSupport(%d)", invocation_id, is_supported);
873 g_dbus_method_invocation_return_value(invocation, reply_body);
874 g_variant_unref(reply_body);
877 return GESTURED_ERROR_NONE;
881 int gestured_reply_get_engine_info(int invocation_id, char* engine_app_id, char* engine_name)
883 GDBusMethodInvocation *invocation = gestureInvocationManagerGet(invocation_id);
884 if (NULL == invocation) {
885 LOGE("Invalid invocation ID");
886 return GESTURED_ERROR_INVALID_PARAMETER;
888 gestureInvocationManagerRemove(invocation_id);
890 if (NULL == engine_app_id || NULL == engine_name) {
891 LOGE("Invalid parameter");
892 g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, GESTURED_ERROR_INVALID_PARAMETER, "Invalid parameter");
893 return GESTURED_ERROR_INVALID_PARAMETER;
896 GVariant *reply_body = g_variant_new("(ss)", engine_app_id, engine_name);
897 if (NULL == reply_body) {
898 LOGE("Fail to create reply_body");
899 g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, GESTURED_ERROR_OPERATION_FAILED, "Fail to create return value");
900 return GESTURED_ERROR_OPERATION_FAILED;
903 LOGD("Invocation ID(%d), APP ID(%s), Name(%s)", invocation_id, engine_app_id, engine_name);
905 g_dbus_method_invocation_return_value(invocation, reply_body);
906 g_variant_unref(reply_body);
909 return GESTURED_ERROR_NONE;
913 static void __response_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
915 LOGD("app_control launch result : %d", result);
918 static bool __is_engine_installed(const char* appid)
920 app_info_h app_info = NULL;
921 int ret = app_manager_get_app_info(appid, &app_info);
922 if (APP_MANAGER_ERROR_NONE != ret || NULL == app_info) {
923 LOGE("[ERROR] There is no tts engine (%s). ret(%d)", appid, ret);
926 LOGI("[INFO] There is tts engine (%s)", appid);
929 ret = app_info_destroy(app_info);
930 if (APP_MANAGER_ERROR_NONE != ret)
931 LOGE("[ERROR] Fail to destroy app_info. ret(%d)", ret);
936 static bool __is_engine_launched(const char* appid)
939 bool is_installed = false;
940 bool is_running = false;
941 is_installed = __is_engine_installed(appid);
943 if (false == is_installed) {
944 LOGW("[WARNING] tts engine(%s) is not installed", appid);
947 ret = app_manager_is_running(appid, &is_running);
948 if (APP_MANAGER_ERROR_NONE != ret) {
949 LOGW("[WARNING] Fail to check whether appid(%s) is running or not. ret(%d)", appid, ret);
950 LOGI("[INFO] tts engine is installed(%d)", is_installed);
953 LOGI("[INFO] tts engine is%s running. is_installed(%d)", (is_running) ? "" : " not", is_installed);
960 int __launch_engine_service_app(char *appid)
962 int ret = GESTURED_ERROR_NONE;
963 app_control_h app_control = NULL;
965 ret = app_control_create(&app_control);
966 if (APP_CONTROL_ERROR_NONE != ret) {
967 LOGD("[ERROR] Fail to create, ret(%d)", ret);
968 return GESTURED_ERROR_OPERATION_FAILED;
972 ret = app_control_set_app_id(app_control, appid);
973 if (APP_CONTROL_ERROR_NONE != ret) {
974 LOGD("[ERROR] Fail to set app id, ret(%d)", ret);
975 app_control_destroy(app_control);
976 return GESTURED_ERROR_OPERATION_FAILED;
979 // Sent launch request
980 ret = app_control_send_launch_request(app_control, __response_cb, NULL);
981 if (APP_CONTROL_ERROR_NONE != ret) {
982 LOGD("[ERROR] Fail to send launch request, ret(%d)", ret);
983 app_control_destroy(app_control);
984 return GESTURED_ERROR_OPERATION_FAILED;
987 // Destroy app control
988 ret = app_control_destroy(app_control);
989 if (APP_CONTROL_ERROR_NONE != ret) {
990 LOGD("[ERROR] Fail to destroy, ret(%d)", ret);
991 return GESTURED_ERROR_OPERATION_FAILED;