server/gestured_dbus.c

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <gio/gio.h>
  21 #include <dlog.h>
  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>
  27
  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"
  34
  35 #ifdef LOG_TAG
  36 #undef LOG_TAG
  37 #endif
  38 #define LOG_TAG "GESTURED_SERVER_DBUS"
  39
  40 #define GESTURE_DIRECTORY tzplatform_mkpath(TZ_SYS_SHARE, "gesture-data")
  41 #define MAX_ERROR_BUFFER  256
  42
  43 static GHashTable *_monitoring_hash;
  44
  45
  46 static GDBusConnection *_gdbus_connection;
  47 static const char *_client_bus_name;
  48 static const char *_engine_bus_name;
  49
  50
  51 static bool __is_engine_installed(const char* appid);
  52 static bool __is_engine_launched(const char* appid);
  53
  54
  55 static cynara *p_cynara = NULL;
  56 static int _cynara_initialize()
  57 {
  58         int ret = cynara_initialize(&p_cynara, NULL);
  59         if (ret != CYNARA_API_SUCCESS)
  60                 LOGE("Failed to cynara initialize");
  61
  62         return ret;
  63 }
  64
  65 static int _check_privilege(const char *uid, const int pid, const char *label, const char *privilege)
  66 {
  67         int ret;
  68
  69         if (!p_cynara) {
  70                 return -1;
  71         }
  72
  73         char *session = cynara_session_from_pid(pid);
  74         ret = cynara_check(p_cynara, label, session, uid, privilege);
  75         if (session)
  76                 free(session);
  77         if (ret != CYNARA_API_ACCESS_ALLOWED) {
  78                 LOGE("Access denied. The result of cynara_check() : %d.", ret);
  79                 return -1;
  80         }
  81
  82         return 0;
  83 }
  84
  85 static void _cynara_deinitialize()
  86 {
  87         if (p_cynara)
  88                 cynara_finish(p_cynara);
  89
  90         p_cynara = NULL;
  91 }
  92
  93 static int _gesture_check_privilege(const char *uid, const int pid, const char *label)
  94 {
  95         int ret = GESTURED_ERROR_NONE;
  96
  97         if (_cynara_initialize() != CYNARA_API_SUCCESS)
  98                 return GESTURED_ERROR_PERMISSION_DENIED;
  99
 100         if (_check_privilege(uid, pid, label, GESTURE_PRIVILEGE_APPLAUNCH) < 0) {
 101                 LOGE("Permission is denied");
 102                 ret = GESTURED_ERROR_PERMISSION_DENIED;
 103         }
 104
 105         _cynara_deinitialize();
 106
 107         return ret;
 108 }
 109
 110
 111
 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)
 114 {
 115         LOGD("server_dbus : gestured_server_register start");
 116
 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;
 122         int client_pid = 0;
 123         char *client_uid = NULL;
 124         char *client_smack_label = NULL;
 125
 126         if (bus_name == NULL)
 127                 return GESTURED_ERROR_IO_ERROR;
 128
 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);
 136
 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);
 141         }
 142
 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");
 147
 148                         return GESTURED_ERROR_PERMISSION_DENIED;
 149                 } else {
 150                         LOGI("[INFO] Permission allowed");
 151                 }
 152
 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");
 158                 } else {
 159                         LOGI("engine is launched");
 160                 }
 161
 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;
 167                 }
 168
 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;
 175                 }
 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(
 181                                 _gdbus_connection,
 182                                 bus_name,
 183                                 G_BUS_NAME_WATCHER_FLAGS_NONE,
 184                                 name_appeared_handler,
 185                                 name_vanished_handler,
 186                                 m_info,
 187                                 NULL);
 188                 if (client->gdbus_watch_id == 0) {
 189                         LOGE("Failed to get identifier");
 190                         GestureManagerClientDestroy(client);
 191                         return GESTURED_ERROR_OPERATION_FAILED;
 192                 }
 193
 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;
 198                 }
 199
 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;
 207                 }
 208
 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;
 215                 }
 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(
 220                                         _gdbus_connection,
 221                                         bus_name,
 222                                         G_BUS_NAME_WATCHER_FLAGS_NONE,
 223                                         name_appeared_handler,
 224                                         name_vanished_handler,
 225                                         m_info,
 226                                         NULL);
 227                 if (engine->gdbus_watch_id == 0) {
 228                         LOGE("Failed to get identifier");
 229                         GestureManagerEngineDestroy(engine);
 230                         return GESTURED_ERROR_OPERATION_FAILED;
 231                 }
 232
 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;
 237                 }
 238                 LOGD("GestureManager Engine count = %d", GestureManagerEngineNums());
 239         }
 240         else {
 241                 LOGE("Error type : CLIENT_LIB must be GESTURE_CLIENT_LIB_GESTURE or GESTURE_CLIENT_LIB_ENGINE");
 242                 return GESTURED_ERROR_OPERATION_FAILED;
 243         }
 244
 245         return GESTURED_ERROR_NONE;
 246 }
 247
 248 int gestured_server_register_dbus_interface(char *introspection_xml, GDBusInterfaceVTable interface_vtable)
 249 {
 250         LOGD("server_dbus : gestured_server_register_dbus_interface start");
 251
 252         int result;
 253         int own_id, registration_id;
 254         GError *error = NULL;
 255         GDBusNodeInfo *introspection_data = NULL;
 256
 257         if (_gdbus_connection == NULL) {
 258                 _gdbus_connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 259                 if (_gdbus_connection == NULL) {
 260                         if (error != NULL) {
 261                                 LOGE("g_bus_get_sync error message = %s", error->message);
 262                                 g_error_free(error);
 263                         }
 264                         result = GESTURED_ERROR_IO_ERROR;
 265                         goto cleanup;
 266                 }
 267         }
 268
 269         own_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
 270                         GESTURE_DBUS_NAME,
 271                         G_BUS_NAME_OWNER_FLAGS_NONE,
 272                         NULL,
 273                         NULL,
 274                         NULL,
 275                         NULL, NULL);
 276         if (own_id == 0) {
 277                 LOGE("Failed to register bus name");
 278                 result = GESTURED_ERROR_IO_ERROR;
 279                 goto cleanup;
 280         }
 281
 282         LOGD("own_id = %d", own_id);
 283
 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;
 288                 if (error != NULL) {
 289                         LOGE("g_dbus_node_info_new_for_xml error message = %s", error->message);
 290                         g_error_free(error);
 291                 }
 292                 goto cleanup;
 293         }
 294
 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;
 301                 goto cleanup;
 302         }
 303
 304         gestureInvocationManagerInit();
 305
 306         return GESTURED_ERROR_NONE;
 307
 308 cleanup:
 309         if (introspection_data)
 310                 g_dbus_node_info_unref(introspection_data);
 311
 312         return result;
 313 }
 314
 315 int delete_monitoring_list(GHashTable **monitoring_hash, const char *sender, uid_t uid)
 316 {
 317         LOGD("server_dbus : delete_monitoring_list start");
 318         int ret = GESTURED_ERROR_NONE;
 319
 320         gesture_manager_client_s *client = NULL;
 321         client = GestureManagerClientGet(sender);
 322         if (!client) {
 323                 LOGD("failed to GestureManagerClientGet");
 324                 return GESTURED_ERROR_OPERATION_FAILED;
 325         }
 326         ret = GestureManagerClientRemove(client);
 327         if (ret != GESTURED_ERROR_NONE) {
 328                 LOGE("Fail to remove client");
 329                 return ret;
 330         }
 331
 332         return GESTURED_ERROR_NONE;
 333 }
 334
 335 int gestured_send_dbus_message(GVariant *body, const char *sender, char *cmd, CLIENT_LIB lib)
 336 {
 337         LOGD("server_dbus : gestured_send_dbus_message [sender = %s] [cmd = %s]", sender, cmd);
 338
 339         GError *err = NULL;
 340         char *interface = NULL;
 341         const char *bus_name = NULL;
 342
 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;
 349         }
 350 #if 1
 351         char *printmsg = g_variant_print(body, true);
 352         LOGD("send_dbus_msg body print : %s", printmsg);
 353         g_free(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);
 356 #endif
 357         if (g_variant_is_floating(body))
 358                 g_variant_ref(body);
 359
 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);
 364 #if 1
 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("==========================");
 374 #endif
 375                         if (!g_dbus_connection_emit_signal(_gdbus_connection,
 376                                                 bus_name,
 377                                                 GESTURE_OBJECT_PATH,
 378                                                 interface,
 379                                                 cmd,
 380                                                 body,
 381                                                 &err)) {
 382                                 if (err != NULL) {
 383                                         LOGE("Failed to send dbus message : %s", err->message);
 384                                         g_error_free(err);
 385                                 }
 386
 387                                 return GESTURED_ERROR_IO_ERROR;
 388                         }
 389                 }
 390         } else {
 391                 if (!g_dbus_connection_emit_signal(_gdbus_connection,
 392                                         bus_name,
 393                                         GESTURE_OBJECT_PATH,
 394                                         interface,
 395                                         cmd,
 396                                         body,
 397                                         &err)) {
 398                         if (err != NULL) {
 399                                 LOGE("Failed to send dbus message : %s", err->message);
 400                                 g_error_free(err);
 401                         }
 402
 403                         return GESTURED_ERROR_IO_ERROR;
 404                 }
 405         }
 406         return GESTURED_ERROR_NONE;
 407 }
 408
 409 static void _on_name_appeared(GDBusConnection *connection,
 410                 const gchar     *name,
 411                 const gchar     *name_owner,
 412                 gpointer         user_data)
 413 {
 414         LOGD("[name: %s] [name_owner: %s]", name, name_owner);
 415 }
 416
 417 static void _on_name_vanished(GDBusConnection *connection,
 418                 const gchar     *name,
 419                 gpointer         user_data)
 420 {
 421         gesture_manager_client_s *client = NULL;
 422         client = GestureManagerClientGetWithBusName(name);
 423         if (!client) {
 424                 LOGD("failed to GestureManagerClientGetWithBusName");
 425         }
 426         int ret = GestureManagerClientRemove(client);
 427         if (ret != GESTURED_ERROR_NONE) {
 428                 LOGE("Fail to remove client");
 429         }
 430         LOGD("GestureManager Client count = %d", GestureManagerClientNums());
 431
 432         gesture_manager_engine_s *engine = NULL;
 433         engine = GestureManagerEngineGetWithBusName(name);
 434         if (!engine) {
 435                 LOGD("failed to GestureManagerEngineGetWithBusName");
 436         }
 437         ret = GestureManagerEngineRemove(engine);
 438         if (ret != GESTURED_ERROR_NONE) {
 439                 LOGE("Fail to remove engine");
 440         }
 441         LOGD("GestureManager Engine count = %d", GestureManagerEngineNums());
 442 }
 443
 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,
 446                 gpointer user_data)
 447 {
 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));
 451
 452         GVariant *reply_body = NULL;
 453         int ret = GESTURED_ERROR_NONE;
 454         bool delay_response = false;
 455
 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);
 460         }
 461         /* from client */
 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);
 465         }
 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);
 469         }
 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);
 473         }
 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);
 477         }
 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);
 481         }
 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);
 485         }
 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;
 490         }
 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;
 495         }
 496
 497         /* from engine */
 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);
 501         }
 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);
 505         }
 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);
 509         }
 510         else if (g_strcmp0(method_name, GESTURE_ENGINE_MSG_MAIN_START) == 0) {
 511                 LOGD("[GESTURE_ENGINE_MSG_MAIN_START] called");
 512         }
 513         else if (g_strcmp0(method_name, GESTURE_ENGINE_MSG_GET_ENGINE_INFO) == 0) {
 514                 LOGD("[GESTURE_ENGINE_MSG_GET_ENGINE_INFO] called");
 515                 int id = -1;
 516                 char* app_id = NULL;
 517                 char* name = NULL;
 518
 519                 g_variant_get(parameters, "(iss)", &id, &app_id, &name);
 520                 ret = gestured_reply_get_engine_info(id, app_id, name);
 521         }
 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");
 524                 int id = -1;
 525                 bool is_supported = false;
 526
 527                 g_variant_get(parameters, "(ib)", &id, &is_supported);
 528                 ret = gestured_reply_is_support_gesture_type(id, is_supported);
 529         }
 530
 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);
 535                 } else {
 536                         LOGE("method_call failed, method_name : %s", method_name);
 537                         g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, ret, "gesture error");
 538                 }
 539         }
 540
 541         if (reply_body)
 542                 g_variant_unref(reply_body);
 543 }
 544
 545 static const GDBusInterfaceVTable _gesture_interface_vtable = {
 546                 _gestured_client_dbus_method_call_handler,
 547                 NULL,
 548                 NULL
 549 };
 550
 551 int gestured_register_dbus_interface(void)
 552 {
 553         LOGD("gestured_register_dbus_interface");
 554
 555         FILE* xml_file = NULL;
 556         char xml_file_path[256] = {'\0', };
 557         char* introspection_xml = NULL;
 558         int size = 0;
 559         int ret = 0;
 560
 561         snprintf(xml_file_path, 256, "%s/capi-ui-gesture-gdbus.xml", GESTURE_SHARED_RESOURCE_PATH);
 562         ret = access(xml_file_path, R_OK);
 563         if (0 != ret) {
 564                 LOGE("Introspection file is not exist. path(%s)", xml_file_path);
 565                 return GESTURED_ERROR_OPERATION_FAILED;
 566         }
 567
 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;
 572         }
 573
 574         fseek(xml_file, 0, SEEK_END);
 575         size = ftell(xml_file);
 576         rewind(xml_file);
 577
 578         introspection_xml = (char*)calloc(sizeof(char), size);
 579         if (NULL == introspection_xml) {
 580                 LOGE("Fail to allocate memory");
 581                 fclose(xml_file);
 582                 return GESTURED_ERROR_OUT_OF_MEMORY;
 583         }
 584
 585         ret = fread(introspection_xml, 1, size, xml_file);
 586         if (ret != size) {
 587                 LOGE("Error is occured reading file");
 588                 fclose(xml_file);
 589                 free(introspection_xml);
 590                 return GESTURED_ERROR_OPERATION_FAILED;
 591         }
 592
 593         ret = gestured_server_register_dbus_interface(introspection_xml, _gesture_interface_vtable);
 594
 595         fclose(xml_file);
 596         free(introspection_xml);
 597
 598         return ret;
 599 }
 600
 601 int gestured_dbus_init(void)
 602 {
 603         LOGD("gestured_dbus_init");
 604         int ret;
 605
 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;
 610         }
 611
 612         return GESTURED_ERROR_NONE;
 613 }
 614
 615 /*******************************************/
 616 /* client side function : client -> daemon */
 617 /* must add logic to send dameon -> engine */
 618 /*******************************************/
 619
 620 int gestured_client_initialize_engine(GVariant *parameters, GVariant **reply_body, const char *sender)
 621 {
 622         int ret = GESTURED_ERROR_NONE;
 623         char *cmd = GESTURE_ENGINE_SIGNAL_ENGINE_INITIALIZE;
 624
 625         if (parameters == NULL) {
 626                 LOGE("failed to get parameters");
 627                 return GESTURED_ERROR_INVALID_PARAMETER;
 628         }
 629
 630         /* check privilege */
 631         gesture_manager_client_s *client = GestureManagerClientGetWithBusName(sender);
 632         if (!client) {
 633                 LOGE("failed to GestureManagerClientGet");
 634                 return GESTURED_ERROR_OPERATION_FAILED;
 635         }
 636
 637         if (false == client->is_permitted) {
 638                 LOGE("[ERROR] Permission denied");
 639                 return GESTURED_ERROR_PERMISSION_DENIED;
 640         }
 641
 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");
 645
 646         return ret;
 647 }
 648
 649 int gestured_client_deinitialize_engine(GVariant *parameters, GVariant **reply_body, const char *sender)
 650 {
 651         int ret = GESTURED_ERROR_NONE;
 652         char *cmd = GESTURE_ENGINE_SIGNAL_ENGINE_DEINITIALIZE;
 653
 654         if (parameters == NULL) {
 655                 LOGE("failed to get parameters");
 656                 return GESTURED_ERROR_INVALID_PARAMETER;
 657         }
 658
 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");
 662
 663         return ret;
 664 }
 665
 666 int gestured_client_start_recognition(GVariant *parameters, GVariant **reply_body, const char *sender)
 667 {
 668         LOGD("gestured_client_start_recognition : sendor [%s]", sender);
 669
 670         int ret = GESTURED_ERROR_NONE;
 671         char *cmd = GESTURE_ENGINE_SIGNAL_ENGINE_START;
 672
 673         if (parameters == NULL) {
 674                 LOGE("failed to get parameters");
 675                 return GESTURED_ERROR_INVALID_PARAMETER;
 676         }
 677
 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;
 682         }
 683
 684         return ret;
 685 }
 686
 687 int gestured_client_stop_recognition(GVariant *parameters, GVariant **reply_body, const char *sender)
 688 {
 689         LOGE("gestured_client_stop_recognition : sendor [%s]", sender);
 690
 691         int ret = GESTURED_ERROR_NONE;
 692         char *cmd = GESTURE_ENGINE_SIGNAL_ENGINE_STOP;
 693
 694         if (parameters == NULL) {
 695                 LOGE("failed to get parameters");
 696                 return GESTURED_ERROR_INVALID_PARAMETER;
 697         }
 698
 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");
 702         }
 703
 704         return ret;
 705 }
 706
 707 int gestured_client_foreach_result_time(GVariant *parameters, GVariant **reply_body, const char *sender)
 708 {
 709         int ret = GESTURED_ERROR_NONE;
 710         char *cmd = GESTURE_ENGINE_SIGNAL_FOREACH_RESULT_TIME;
 711
 712         if (parameters == NULL) {
 713                 LOGE("failed to get parameters");
 714                 return GESTURED_ERROR_INVALID_PARAMETER;
 715         }
 716
 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");
 720
 721         return ret;
 722 }
 723
 724 int gestured_client_foreach_supported_type(GVariant *parameters, GVariant **reply_body, const char *sender)
 725 {
 726         int ret = GESTURED_ERROR_NONE;
 727         char *cmd = GESTURE_ENGINE_SIGNAL_FOREACH_SUPPORTED_TYPE;
 728
 729         if (parameters == NULL) {
 730                 LOGE("failed to get parameters");
 731                 return GESTURED_ERROR_INVALID_PARAMETER;
 732         }
 733
 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");
 737
 738         return ret;
 739 }
 740
 741 int gestured_client_is_support_gesture_type(GVariant *parameters, GVariant **reply_body, const char *sender, GDBusMethodInvocation* invocation)
 742 {
 743         int ret = GESTURED_ERROR_NONE;
 744         char *cmd = GESTURE_ENGINE_SIGNAL_IS_SUPPORT_GESTURE_TYPE;
 745
 746         if (parameters == NULL) {
 747                 LOGE("failed to get parameters");
 748                 return GESTURED_ERROR_INVALID_PARAMETER;
 749         }
 750
 751         int id = gestureInvocationManagerAdd(invocation);
 752         if (0 > id) {
 753                 LOGE("Fail to store invocation");
 754                 return GESTURED_ERROR_OPERATION_FAILED;
 755         }
 756
 757         int gesture_type = 0;
 758         g_variant_get(parameters, "(i)", &gesture_type);
 759
 760         LOGD("invocation id (%d), gesture type(%d)", id, gesture_type);
 761         GVariant* body = g_variant_new("(ii)", id, gesture_type);
 762         if (NULL == body) {
 763                 LOGE("Fail to create body");
 764                 return GESTURED_ERROR_OPERATION_FAILED;
 765         }
 766
 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");
 770
 771         return ret;
 772 }
 773
 774 int gestured_client_get_engine_info(GVariant *parameters, GVariant **reply_body, const char *sender, GDBusMethodInvocation* invocation)
 775 {
 776         LOGD("[engineInfo] gestured_client_get_engine_info : sendor [%s]", sender);
 777
 778         int ret = GESTURED_ERROR_NONE;
 779         char *cmd = GESTURE_ENGINE_SIGNAL_GET_ENGINE_INFO;
 780
 781         if (parameters == NULL) {
 782                 LOGE("failed to get parameters");
 783                 return GESTURED_ERROR_INVALID_PARAMETER;
 784         }
 785
 786         int id = gestureInvocationManagerAdd(invocation);
 787         if (0 > id) {
 788                 LOGE("Fail to store invocation");
 789                 return GESTURED_ERROR_OPERATION_FAILED;
 790         }
 791
 792         LOGD("invocation ID (%d)", id);
 793         GVariant* body = g_variant_new("(i)", id);
 794         if (NULL == body) {
 795                 LOGE("Fail to create body");
 796                 return GESTURED_ERROR_OPERATION_FAILED;
 797         }
 798
 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");
 802
 803         return ret;
 804 }
 805
 806 /*******************************************/
 807 /* engine side function : engine -> daemon */
 808 /* must add logic to send dameon -> client */
 809 /*******************************************/
 810
 811 int gestured_engine_send_result(GVariant *parameters, GVariant **reply_body, const char *sender)
 812 {
 813         LOGD("gestured_engine_send_result : sendor [%s]", sender);
 814 #if 0
 815         int event, gesture_type, ltype, levent, lcount;
 816         g_variant_get(parameters, "(iiiii)", &event, &gesture_type, &ltype, &levent, &lcount);
 817         LOGD("[event = %d] [gesture_type = %d] [ltype = %d] [levent = %d] [lcount = %d]", event, gesture_type, ltype, levent, lcount);
 818 #endif
 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);
 822         return ret;
 823 }
 824
 825 int gestured_engine_send_error(GVariant *parameters, GVariant **reply_body, const char *sender)
 826 {
 827         LOGE("gestured_engine_send_error : sendor [%s]", sender);
 828
 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);
 832         return ret;
 833 }
 834
 835 int gestured_engine_send_motion_status(GVariant *parameters, GVariant **reply_body, const char *sender)
 836 {
 837         LOGE("gestured_engine_send_motion_status : sendor [%s]", sender);
 838
 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);
 842         return ret;
 843 }
 844
 845 int gestured_engine_send_engine_get_info(GVariant *parameters, GVariant **reply_body, const char *sender)
 846 {
 847         LOGD("[engineInfo] gestured_engine_send_engine_get_info : sendor [%s]", sender);
 848
 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);
 852         return ret;
 853 }
 854
 855 int gestured_reply_is_support_gesture_type(int invocation_id, bool is_supported)
 856 {
 857         GDBusMethodInvocation *invocation = gestureInvocationManagerGet(invocation_id);
 858         if (NULL == invocation) {
 859                 LOGE("Invalid invocation ID");
 860                 return GESTURED_ERROR_INVALID_PARAMETER;
 861         }
 862         gestureInvocationManagerRemove(invocation_id);
 863
 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;
 869         }
 870
 871         LOGD("Invocation ID(%d), IsSupport(%d)", invocation_id, is_supported);
 872
 873         g_dbus_method_invocation_return_value(invocation, reply_body);
 874         g_variant_unref(reply_body);
 875         reply_body = NULL;
 876
 877         return GESTURED_ERROR_NONE;
 878 }
 879
 880
 881 int gestured_reply_get_engine_info(int invocation_id, char* engine_app_id, char* engine_name)
 882 {
 883         GDBusMethodInvocation *invocation = gestureInvocationManagerGet(invocation_id);
 884         if (NULL == invocation) {
 885                 LOGE("Invalid invocation ID");
 886                 return GESTURED_ERROR_INVALID_PARAMETER;
 887         }
 888         gestureInvocationManagerRemove(invocation_id);
 889
 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;
 894         }
 895
 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;
 901         }
 902
 903         LOGD("Invocation ID(%d), APP ID(%s), Name(%s)", invocation_id, engine_app_id, engine_name);
 904
 905         g_dbus_method_invocation_return_value(invocation, reply_body);
 906         g_variant_unref(reply_body);
 907         reply_body = NULL;
 908
 909         return GESTURED_ERROR_NONE;
 910 }
 911
 912
 913 static void __response_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
 914 {
 915         LOGD("app_control launch result : %d", result);
 916 }
 917
 918 static bool __is_engine_installed(const char* appid)
 919 {
 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);
 924         return false;
 925     } else {
 926         LOGI("[INFO] There is tts engine (%s)", appid);
 927     }
 928
 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);
 932
 933     return true;
 934 }
 935
 936 static bool __is_engine_launched(const char* appid)
 937 {
 938     int ret = -1;
 939     bool is_installed = false;
 940     bool is_running = false;
 941     is_installed = __is_engine_installed(appid);
 942
 943     if (false == is_installed) {
 944         LOGW("[WARNING] tts engine(%s) is not installed", appid);
 945         return false;
 946     } else {
 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);
 951             return false;
 952         } else {
 953             LOGI("[INFO] tts engine is%s running. is_installed(%d)", (is_running) ? "" : " not", is_installed);
 954         }
 955
 956         return is_running;
 957     }
 958 }
 959
 960 int __launch_engine_service_app(char *appid)
 961 {
 962         int ret = GESTURED_ERROR_NONE;
 963         app_control_h app_control = NULL;
 964
 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;
 969         }
 970
 971         // Set an app ID.
 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;
 977         }
 978
 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;
 985         }
 986
 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;
 992         }
 993
 994         return ret;
 995 }
 996