engine/gesture_engine.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 <dlog.h>
  21 #include <app_common.h>
  22 #include <package_manager.h>
  23
  24 #include "gesture_engine.h"
  25 #include "gesture_engine_main.h"
  26 #include "gesture_engine_dbus.h"
  27
  28 #ifdef LOG_TAG
  29 #undef LOG_TAG
  30 #endif
  31 #define LOG_TAG "GESTURE_ENGINE"
  32
  33 EXPORT_API int gesture_engine_connect(gesture_engine_h *engine_handle)
  34 {
  35         LOGD("gesture_engine_connect start");
  36         CHECK_GESTURE_FEATURE();
  37
  38         int ret;
  39         if (!engine_handle)
  40                 return GESTURE_ENGINE_ERROR_INVALID_PARAMETER;
  41
  42         struct gesture_engine_s *engine_struct = (gesture_engine_h)calloc(1, sizeof(struct gesture_engine_s));
  43
  44         if (!engine_struct)
  45                 return GESTURE_ENGINE_ERROR_OUT_OF_MEMORY;
  46
  47         ret = gesture_engine_dbus_init(&engine_struct->gdbus_connection, &engine_struct->server_watcher_id,
  48                         &engine_struct->monitor_id, &engine_struct->server_monitor_id, GESTURE_CLIENT_LIB_ENGINE, (void *)engine_struct);
  49         if (ret != GESTURE_ENGINE_ERROR_NONE) {
  50                 LOGE("Failed to initialize dbus : %d", ret);
  51                 free(engine_struct);
  52                 return GESTURE_ENGINE_ERROR_OPERATION_FAILED;
  53         }
  54
  55         *engine_handle = engine_struct;
  56
  57         return GESTURE_ENGINE_ERROR_NONE;
  58 }
  59
  60 EXPORT_API int gesture_engine_disconnect(gesture_engine_h engine_handle)
  61 {
  62         CHECK_GESTURE_FEATURE();
  63
  64         int ret;
  65         if (!engine_handle)
  66                 return GESTURE_ENGINE_ERROR_INVALID_PARAMETER;
  67
  68         ret = gesture_engine_dbus_shutdown(engine_handle->gdbus_connection, &engine_handle->server_monitor_id, &engine_handle->monitor_id);
  69         if (ret != GESTURE_ENGINE_ERROR_NONE) {
  70                 LOGE("Failed to finalize dbus : %d", ret);
  71                 free(engine_handle);
  72                 return GESTURE_ENGINE_ERROR_OPERATION_FAILED;
  73         }
  74
  75         if (engine_handle->gdbus_connection)
  76                 g_object_unref(engine_handle->gdbus_connection);
  77
  78         free(engine_handle);
  79
  80         return GESTURE_ENGINE_ERROR_NONE;
  81 }
  82
  83 EXPORT_API int gesture_engine_main(int argc, char** argv, gesture_engine_h engine_handle, gesture_engine_request_callback_s *callback)
  84 {
  85         LOGD("gesture_engine_main start");
  86
  87         CHECK_GESTURE_FEATURE();
  88
  89         if (!callback) {
  90                 LOGE("basic engine callbacks pointer is null.");
  91                 return GESTURE_ENGINE_ERROR_INVALID_PARAMETER;
  92         }
  93
  94         int ret = GESTURE_ENGINE_ERROR_NONE;
  95
  96         ret = gesture_engine_dbus_main_start(engine_handle->gdbus_connection, callback);
  97         if (ret != GESTURE_ENGINE_ERROR_NONE) {
  98                 LOGE("Failed to start engine main : %d", ret);
  99                 return GESTURE_ENGINE_ERROR_OPERATION_FAILED;
 100         }
 101
 102         return 0;
 103 }
 104
 105 EXPORT_API int gesture_engine_send_result(gesture_engine_h engine_handle, gesture_engine_result_event_e event, hand_gesture_type_e gesture_type, hand_gesture_data_h result, void* time_info, void* user_data)
 106 {
 107         LOGD("gesture_engine_send_result start");
 108         LOGD("gesture type = %d", gesture_type);
 109
 110         CHECK_GESTURE_FEATURE();
 111
 112         if (!engine_handle) {
 113                 LOGE("invalid parameter : engine_handle");
 114                 return GESTURE_ENGINE_ERROR_INVALID_PARAMETER;
 115         }
 116
 117         int ret = GESTURE_ENGINE_ERROR_NONE;
 118
 119         ret = gesture_engine_dbus_send_result(engine_handle->gdbus_connection, event, gesture_type, result, time_info, user_data);
 120         if (ret != GESTURE_ENGINE_ERROR_NONE) {
 121                 LOGE("Failed to send result : %d", ret);
 122                 return GESTURE_ENGINE_ERROR_OPERATION_FAILED;
 123         }
 124
 125         return ret;
 126 }
 127
 128 EXPORT_API int gesture_engine_send_error(gesture_engine_h engine_handle, gesture_engine_error_e error, const char* msg)
 129 {
 130         LOGD("gesture_engine_send_error start");
 131         LOGD("error type = %d", error);
 132         LOGD("msg = %s", msg);
 133
 134         CHECK_GESTURE_FEATURE();
 135
 136         if (!engine_handle) {
 137                 LOGE("invalid parameter : engine_handle");
 138                 return GESTURE_ENGINE_ERROR_INVALID_PARAMETER;
 139         }
 140
 141         int ret = GESTURE_ENGINE_ERROR_NONE;
 142
 143         ret = gesture_engine_dbus_send_error(engine_handle->gdbus_connection, error, msg);
 144         if (ret != GESTURE_ENGINE_ERROR_NONE) {
 145                 LOGE("Failed to send result : %d", ret);
 146                 return GESTURE_ENGINE_ERROR_OPERATION_FAILED;
 147         }
 148
 149         return 0;
 150 }
 151
 152 EXPORT_API int gesture_engine_send_motion_status(gesture_engine_h engine_handle, gesture_engine_motion_status_e status, void* user_data)
 153 {
 154         LOGD("gesture_engine_send_motion_status start");
 155         LOGD("motion status = %d", status);
 156
 157         CHECK_GESTURE_FEATURE();
 158
 159         if (!engine_handle) {
 160                 LOGE("invalid parameter : engine_handle");
 161                 return GESTURE_ENGINE_ERROR_INVALID_PARAMETER;
 162         }
 163
 164         int ret = GESTURE_ENGINE_ERROR_NONE;
 165
 166         ret = gesture_engine_dbus_send_motion_status(engine_handle->gdbus_connection, status, user_data);
 167         if (ret != GESTURE_ENGINE_ERROR_NONE) {
 168                 LOGE("Failed to send motion status : %d", ret);
 169                 return GESTURE_ENGINE_ERROR_OPERATION_FAILED;
 170         }
 171
 172         return 0;
 173 }
 174
 175 EXPORT_API int gesture_engine_set_private_data_set_cb(gesture_engine_h engine_handle, gesture_engine_private_data_set_cb callback_func)
 176 {
 177         return 0;
 178 }
 179
 180 EXPORT_API int gesture_engine_set_private_data_requested_cb(gesture_engine_h engine_handle, gesture_engine_private_data_requested_cb callback_func)
 181 {
 182         return 0;
 183 }
 184
 185 EXPORT_API int gesture_engine_send_engine_get_info(gesture_engine_h engine_handle, char* engine_app_id, char* engine_name)
 186 {
 187         LOGD("gesture engine_app_id = %s", engine_app_id);
 188
 189         CHECK_GESTURE_FEATURE();
 190
 191         if (!engine_handle) {
 192                 LOGE("invalid parameter : engine_handle");
 193                 return GESTURE_ENGINE_ERROR_INVALID_PARAMETER;
 194         }
 195
 196         int ret = GESTURE_ENGINE_ERROR_NONE;
 197
 198         ret = gesture_engine_dbus_send_engine_get_info(engine_handle->gdbus_connection, engine_app_id, engine_name);
 199         if (ret != GESTURE_ENGINE_ERROR_NONE) {
 200                 LOGE("Failed to send result : %d", ret);
 201                 return GESTURE_ENGINE_ERROR_OPERATION_FAILED;
 202         }
 203
 204         return ret;
 205 }
 206