TC/testcase/utc_sync_agent_framework_event.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <tet_api.h>
  19
  20 #include <sync_agent.h>
  21
  22 enum {
  23         POSITIVE_TC_IDX = 0x01,
  24         NEGATIVE_TC_IDX,
  25 };
  26
  27 static void startup(void);
  28 static void cleanup(void);
  29
  30 void (*tet_startup) (void) = startup;
  31 void (*tet_cleanup) (void) = cleanup;
  32
  33 #define TEST_FW_CONFIG_FILE     "../../../testcase/fw-test-cfg/test_fw_config.xml"
  34
  35 #define EVENT_NUM 1
  36 #define NOTI_NUM 1
  37 #define NOTI_KEY "fw_test_noti"
  38
  39 #define API_NAME_SYNC_START_UP  "startup"
  40 #define API_NAME_SYNC_CLEAN_UP  "cleanup"
  41 #define API_NAME_EVENT_CB "_event_cb"
  42 #define API_NAME_CANCEL_CB "_cancel_cb"
  43 #define API_NAME_NOTI_CB "_noti_cb"
  44
  45 #define API_NAME_SYNC_AGENT_APPEND_EVENT_DATA_PARAM "sync_agent_append_event_data_param"
  46 #define API_NAME_SYNC_AGENT_GET_EVENT_DATA_PARAM "sync_agent_get_event_data_param"
  47 #define API_NAME_SYNC_AGENT_RUN_EVENT_HANDLER "sync_agent_run_event_handler"
  48 #define API_NAME_SYNC_AGENT_SET_EVENT_CALLBACK "sync_agent_set_event_callback"
  49 #define API_NAME_SYNC_AGENT_CREATE_NOTI "sync_agent_create_noti"
  50 #define API_NAME_SYNC_AGENT_SEND_NOTI "sync_agent_send_noti"
  51 #define API_NAME_SYNC_AGENT_CREATE_EVENT "sync_agent_create_event"
  52 #define API_NAME_SYNC_AGENT_SEND_EVENT "sync_agent_send_event"
  53 #define API_NAME_SYNC_AGENT_RUN_NOTI_LISTENER "sync_agent_run_noti_listener"
  54 #define API_NAME_SYNC_AGENT_STOP_NOTI_LISTENER "sync_agent_stop_noti_listener"
  55 #define API_NAME_SYNC_AGENT_SET_NOTI_CALLBACK "sync_agent_set_noti_callback"
  56 #define API_NAME_SYNC_AGENT_CLEAN_EVENT_HANDLER "sync_agent_clean_event_handler"
  57
  58 static void utc_sync_agent_framework_sync_agent_append_event_data_param_p(void);
  59 static void utc_sync_agent_framework_sync_agent_get_event_data_param_p(void);
  60 static void utc_sync_agent_framework_sync_agent_run_event_handler_p(void);
  61 static void utc_sync_agent_framework_sync_agent_set_event_callback_p(void);
  62 static void utc_sync_agent_framework_sync_agent_set_event_callback_n(void);
  63 static void utc_sync_agent_framework_sync_agent_create_noti_p(void);
  64 static void utc_sync_agent_framework_sync_agent_send_noti_p(void);
  65 static void utc_sync_agent_framework_sync_agent_send_noti_n(void);
  66 static void utc_sync_agent_framework_sync_agent_create_event_p(void);
  67 static void utc_sync_agent_framework_sync_agent_send_event_p(void);
  68 static void utc_sync_agent_framework_sync_agent_send_event_n(void);
  69 static void utc_sync_agent_framework_sync_agent_run_noti_listener_p(void);
  70 static void utc_sync_agent_framework_sync_agent_run_noti_listener_n(void);
  71 static void utc_sync_agent_framework_sync_agent_stop_noti_listener_p(void);
  72 static void utc_sync_agent_framework_sync_agent_set_noti_callback_p(void);
  73 static void utc_sync_agent_framework_sync_agent_clean_event_handler_p(void);
  74
  75 static int _event_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  76 static sync_agent_event_ipc_cancel_e _cancel_cb(void *user_data);
  77 static int _noti_cb(sync_agent_event_data_s * noti, void *user_data);
  78
  79 struct tet_testlist tet_testlist[] = {
  80         {utc_sync_agent_framework_sync_agent_append_event_data_param_p, POSITIVE_TC_IDX},
  81         {utc_sync_agent_framework_sync_agent_get_event_data_param_p, POSITIVE_TC_IDX},
  82         {utc_sync_agent_framework_sync_agent_run_event_handler_p, POSITIVE_TC_IDX},
  83         {utc_sync_agent_framework_sync_agent_set_event_callback_p, POSITIVE_TC_IDX},
  84         {utc_sync_agent_framework_sync_agent_set_event_callback_n, NEGATIVE_TC_IDX},
  85         {utc_sync_agent_framework_sync_agent_create_noti_p, POSITIVE_TC_IDX},
  86         {utc_sync_agent_framework_sync_agent_send_noti_p, POSITIVE_TC_IDX},
  87         {utc_sync_agent_framework_sync_agent_send_noti_n, NEGATIVE_TC_IDX},
  88         {utc_sync_agent_framework_sync_agent_create_event_p, POSITIVE_TC_IDX},
  89         {utc_sync_agent_framework_sync_agent_send_event_p, POSITIVE_TC_IDX},
  90         {utc_sync_agent_framework_sync_agent_send_event_n, NEGATIVE_TC_IDX},
  91         {utc_sync_agent_framework_sync_agent_run_noti_listener_p, POSITIVE_TC_IDX},
  92         {utc_sync_agent_framework_sync_agent_run_noti_listener_n, NEGATIVE_TC_IDX},
  93         {utc_sync_agent_framework_sync_agent_stop_noti_listener_p, POSITIVE_TC_IDX},
  94         {utc_sync_agent_framework_sync_agent_set_noti_callback_p, POSITIVE_TC_IDX},
  95         {utc_sync_agent_framework_sync_agent_clean_event_handler_p, POSITIVE_TC_IDX},
  96         {NULL, 0}
  97 };
  98
  99 static void startup(void)
 100 {
 101         /* start of TC */
 102         sync_agent_init_error_e init_error = sync_agent_init(TEST_FW_CONFIG_FILE);
 103         if (init_error != SYNC_AGENT_INIT_SUCCESS) {
 104                 dts_message(API_NAME_SYNC_START_UP, "sync_agent_init : %d", init_error);
 105                 dts_fail(API_NAME_SYNC_START_UP);
 106         }
 107
 108         sync_agent_event_error_e event_err = sync_agent_set_event_callback(EVENT_NUM, _event_cb);
 109         if (event_err != SYNC_AGENT_EVENT_SUCCESS) {
 110                 dts_message(API_NAME_SYNC_START_UP, "sync_agent_set_event_callback : %d", event_err);
 111                 dts_fail(API_NAME_SYNC_START_UP);
 112         }
 113
 114         event_err = sync_agent_set_noti_callback(NOTI_NUM, _noti_cb, NULL);
 115         if (event_err != SYNC_AGENT_EVENT_SUCCESS) {
 116                 dts_message(API_NAME_SYNC_START_UP, "sync_agent_set_noti_callback : %d", event_err);
 117                 dts_fail(API_NAME_SYNC_START_UP);
 118         }
 119
 120         /* todo : register event callback  x */
 121
 122         /* create noti listener  x */
 123 }
 124
 125 static void cleanup(void)
 126 {
 127         /* clean of TC */
 128         sync_agent_event_error_e event_err = sync_agent_clean_event_handler();
 129 }
 130
 131 static void utc_sync_agent_framework_sync_agent_append_event_data_param_p(void)
 132 {
 133         char *api_name = API_NAME_SYNC_AGENT_APPEND_EVENT_DATA_PARAM;
 134         sync_agent_event_data_s *request_event = NULL;
 135         int event_int_data = 1;
 136
 137         request_event = sync_agent_create_event(EVENT_NUM);
 138         if (request_event != NULL) {
 139                 sync_agent_append_event_data_param(request_event, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_int_data);
 140                 sync_agent_free_event_data(request_event);
 141                 dts_pass(api_name);
 142         } else {
 143                 dts_message(api_name, "sync_agent_create_event");
 144                 dts_fail(api_name);
 145         }
 146 }
 147
 148 static void utc_sync_agent_framework_sync_agent_get_event_data_param_p(void)
 149 {
 150         char *api_name = API_NAME_SYNC_AGENT_GET_EVENT_DATA_PARAM;
 151         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 152         sync_agent_event_data_s *request_event = NULL;
 153         sync_agent_event_data_s *response_event = NULL;
 154         int event_int_data = 1;
 155         char *event_char_data = strdup("event data");
 156         int result_int = 0;
 157
 158         request_event = sync_agent_create_event(EVENT_NUM);
 159         if (request_event == NULL) {
 160                 dts_message(api_name, "sync_agent_create_event");
 161                 dts_fail(api_name);
 162         }
 163
 164         sync_agent_append_event_data_param(request_event, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_int_data);
 165         sync_agent_append_event_data_param(request_event, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, event_char_data);
 166
 167         response_event = sync_agent_send_event(request_event, &event_err);
 168
 169         if (event_err != SYNC_AGENT_EVENT_SUCCESS) {
 170                 dts_message(api_name, "sync_agent_send_event : %d", event_err);
 171                 sync_agent_free_event_data(response_event);
 172                 sync_agent_free_event_data(request_event);
 173                 dts_fail(api_name);
 174         }
 175
 176         if (response_event != NULL) {
 177                 sync_agent_get_event_data_param(response_event, &result_int);
 178                 dts_message(api_name, "sync_agent_get_event_data_param (event result) : %d", result_int);
 179                 sync_agent_free_event_data(request_event);
 180                 sync_agent_free_event_data(response_event);
 181                 dts_pass(api_name);
 182         } else {
 183                 sync_agent_free_event_data(request_event);
 184                 dts_message(api_name, "sync_agent_send_event : %d", event_err);
 185                 dts_fail(api_name);
 186         }
 187 }
 188
 189 static void utc_sync_agent_framework_sync_agent_run_event_handler_p(void)
 190 {
 191         char *api_name = API_NAME_SYNC_AGENT_RUN_EVENT_HANDLER;
 192         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 193         unsigned long int thread_id = 0;
 194
 195         event_err = sync_agent_run_event_handler(&thread_id);
 196         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 197                 pthread_cancel(thread_id);
 198                 dts_pass(api_name);
 199         } else {
 200                 dts_message(api_name, "sync_agent_run_event_handler : %d", event_err);
 201                 dts_fail(api_name);
 202         }
 203 }
 204
 205 static void utc_sync_agent_framework_sync_agent_set_event_callback_p(void)
 206 {
 207         char *api_name = API_NAME_SYNC_AGENT_SET_EVENT_CALLBACK;
 208         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 209
 210         event_err = sync_agent_set_event_callback(EVENT_NUM, _event_cb);
 211         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 212                 dts_pass(api_name);
 213         } else {
 214                 dts_message(api_name, "sync_agent_set_event_callback : %d", event_err);
 215                 dts_fail(api_name);
 216         }
 217 }
 218
 219 static void utc_sync_agent_framework_sync_agent_set_event_callback_n(void)
 220 {
 221         char *api_name = API_NAME_SYNC_AGENT_SET_EVENT_CALLBACK;
 222         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 223
 224         int event_num = 3;      /* not defined event */
 225
 226         event_err = sync_agent_set_event_callback(event_num, _event_cb);
 227         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 228                 dts_message(api_name, "sync_agent_set_event_callback : %d", event_err);
 229                 dts_fail(api_name);
 230         } else {
 231                 dts_pass(api_name);
 232         }
 233 }
 234
 235 static void utc_sync_agent_framework_sync_agent_create_noti_p(void)
 236 {
 237         char *api_name = API_NAME_SYNC_AGENT_CREATE_NOTI;
 238         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 239         sync_agent_event_data_s *noti = NULL;
 240
 241         noti = sync_agent_create_noti(NOTI_NUM);
 242         if (noti != NULL) {
 243                 sync_agent_free_noti(noti);
 244                 dts_pass(api_name);
 245         } else {
 246                 dts_message(api_name, "sync_agent_create_noti : %d", event_err);
 247                 dts_fail(api_name);
 248         }
 249 }
 250
 251 static void utc_sync_agent_framework_sync_agent_send_noti_p(void)
 252 {
 253         char *api_name = API_NAME_SYNC_AGENT_SEND_NOTI;
 254         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 255         sync_agent_event_data_s *noti = NULL;
 256         sync_agent_event_data_s *response = NULL;
 257         int noti_int_data = 0;
 258         char *noti_char_data = strdup("noti data");
 259         void *user_data = NULL;
 260
 261         event_err = sync_agent_run_noti_listener(NOTI_KEY);
 262         if (event_err != SYNC_AGENT_EVENT_SUCCESS) {
 263                 dts_message(api_name, "sync_agent_run_noti_listener : %d", event_err);
 264                 dts_fail(api_name);
 265         }
 266
 267         sync_agent_run_main_loop(1);
 268
 269         noti = sync_agent_create_noti(NOTI_NUM);
 270         if (noti == NULL) {
 271                 dts_message(api_name, "sync_agent_create_noti : %d", event_err);
 272                 dts_fail(api_name);
 273         }
 274
 275         sync_agent_append_event_data_param(noti, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &noti_int_data);
 276         sync_agent_append_event_data_param(noti, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, noti_char_data);
 277
 278         sync_agent_send_noti(NOTI_KEY, noti, _cancel_cb, user_data, &event_err);
 279
 280         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 281                 sync_agent_free_noti(noti);
 282                 dts_pass(api_name);
 283         } else {
 284                 sync_agent_free_noti(noti);
 285                 dts_message(api_name, "sync_agent_send_noti : %d", event_err);
 286                 dts_fail(api_name);
 287         }
 288 }
 289
 290 static void utc_sync_agent_framework_sync_agent_send_noti_n(void)
 291 {
 292         char *api_name = API_NAME_SYNC_AGENT_SEND_NOTI;
 293         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 294         sync_agent_event_data_s *noti = NULL;
 295         sync_agent_event_data_s *response = NULL;
 296         int noti_int_data = 0;
 297         char *noti_char_data = strdup("noti data");
 298         void *user_data = NULL;
 299
 300         event_err = sync_agent_run_noti_listener(NULL);
 301         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 302                 dts_message(api_name, "sync_agent_run_noti_listener : %d", event_err);
 303                 dts_fail(api_name);
 304         }
 305
 306         sync_agent_run_main_loop(1);
 307
 308         noti = sync_agent_create_noti(NOTI_NUM);
 309         if (noti == NULL) {
 310                 dts_message(api_name, "sync_agent_create_noti : %d", event_err);
 311                 dts_fail(api_name);
 312         }
 313
 314         sync_agent_append_event_data_param(noti, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &noti_int_data);
 315         sync_agent_append_event_data_param(noti, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, noti_char_data);
 316
 317         sync_agent_send_noti(NULL, noti, _cancel_cb, user_data, &event_err);
 318
 319         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 320                 sync_agent_free_noti(noti);
 321                 dts_message(api_name, "sync_agent_send_noti : %d", event_err);
 322                 dts_fail(api_name);
 323         } else {
 324                 sync_agent_free_noti(noti);
 325                 dts_pass(api_name);
 326         }
 327 }
 328
 329 static void utc_sync_agent_framework_sync_agent_create_event_p(void)
 330 {
 331         char *api_name = API_NAME_SYNC_AGENT_CREATE_EVENT;
 332         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 333         sync_agent_event_data_s *event = NULL;
 334
 335         event = sync_agent_create_event(EVENT_NUM);
 336         if (event != NULL) {
 337                 sync_agent_free_noti(event);
 338                 dts_pass(api_name);
 339         } else {
 340                 dts_message(api_name, "sync_agent_create_noti : %d", event_err);
 341                 dts_fail(api_name);
 342         }
 343 }
 344
 345 static void utc_sync_agent_framework_sync_agent_send_event_p(void)
 346 {
 347         char *api_name = API_NAME_SYNC_AGENT_SEND_EVENT;
 348         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 349         sync_agent_event_data_s *request = NULL;
 350         sync_agent_event_data_s *response = NULL;
 351         int event_int_data = 0;
 352         char *event_char_data = strdup("event data");
 353         int event_result = 0;
 354
 355         request = sync_agent_create_event(EVENT_NUM);
 356         if (request == NULL) {
 357                 dts_message(api_name, "sync_agent_create_event : %d", event_err);
 358                 dts_fail(api_name);
 359         }
 360
 361         sync_agent_append_event_data_param(request, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_int_data);
 362         sync_agent_append_event_data_param(request, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, event_char_data);
 363
 364         response = sync_agent_send_event(request, &event_err);
 365
 366         if (event_err != SYNC_AGENT_EVENT_SUCCESS) {
 367                 dts_message(api_name, "sync_agent_send_event : %d", event_err);
 368                 sync_agent_free_event(request);
 369                 sync_agent_free_event(response);
 370                 dts_fail(api_name);
 371         }
 372
 373         if (response != NULL) {
 374                 sync_agent_get_event_data_param(response, &event_result);
 375                 dts_message(api_name, "sync_agent_get_event_data_param (event result) : %d", event_result);
 376                 sync_agent_free_event(request);
 377                 sync_agent_free_event(response);
 378                 dts_pass(api_name);
 379         } else {
 380                 dts_message(api_name, "sync_agent_send_event : %d", event_err);
 381                 sync_agent_free_event(request);
 382                 dts_fail(api_name);
 383         }
 384 }
 385
 386 static void utc_sync_agent_framework_sync_agent_send_event_n(void)
 387 {
 388         char *api_name = API_NAME_SYNC_AGENT_SEND_EVENT;
 389         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 390         sync_agent_event_data_s *request = NULL;
 391         sync_agent_event_data_s *response = NULL;
 392         int event_int_data = 0;
 393         char *event_char_data = strdup("event data");
 394         int event_result = 0;
 395
 396         request = sync_agent_create_event(EVENT_NUM);
 397         if (request == NULL) {
 398                 dts_message(api_name, "sync_agent_create_event : %d", event_err);
 399                 dts_fail(api_name);
 400         }
 401
 402         sync_agent_append_event_data_param(request, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_int_data);
 403         sync_agent_append_event_data_param(request, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, event_char_data);
 404
 405         response = sync_agent_send_event(NULL, &event_err);
 406
 407         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 408                 dts_message(api_name, "sync_agent_send_event : %d", event_err);
 409                 sync_agent_free_event(request);
 410                 sync_agent_free_event(response);
 411                 dts_fail(api_name);
 412         }
 413
 414         if (response != NULL) {
 415                 dts_message(api_name, "sync_agent_send_event : %d", event_err);
 416                 sync_agent_free_event(request);
 417                 dts_fail(api_name);
 418         } else {
 419                 sync_agent_get_event_data_param(response, &event_result);
 420                 dts_message(api_name, "sync_agent_get_event_data_param (event result) : %d", event_result);
 421                 sync_agent_free_event(request);
 422                 sync_agent_free_event(response);
 423                 dts_pass(api_name);
 424         }
 425 }
 426
 427 static void utc_sync_agent_framework_sync_agent_run_noti_listener_p(void)
 428 {
 429         char *api_name = API_NAME_SYNC_AGENT_RUN_NOTI_LISTENER;
 430         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 431
 432         event_err = sync_agent_run_noti_listener(NOTI_KEY);
 433         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 434                 dts_pass(api_name);
 435         } else {
 436                 dts_message(api_name, "sync_agent_run_noti_listener : %d", event_err);
 437                 dts_fail(api_name);
 438         }
 439 }
 440
 441 static void utc_sync_agent_framework_sync_agent_run_noti_listener_n(void)
 442 {
 443         char *api_name = API_NAME_SYNC_AGENT_RUN_NOTI_LISTENER;
 444         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 445
 446         event_err = sync_agent_run_noti_listener(NULL);
 447         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 448                 dts_message(api_name, "sync_agent_run_noti_listener : %d", event_err);
 449                 dts_fail(api_name);
 450         } else {
 451                 dts_pass(api_name);
 452         }
 453 }
 454
 455 static void utc_sync_agent_framework_sync_agent_stop_noti_listener_p(void)
 456 {
 457         char *api_name = API_NAME_SYNC_AGENT_STOP_NOTI_LISTENER;
 458         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 459
 460         event_err = sync_agent_stop_noti_listener();
 461         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 462                 dts_pass(api_name);
 463         } else {
 464                 dts_message(api_name, "sync_agent_stop_noti_listener : %d", event_err);
 465                 dts_fail(api_name);
 466         }
 467 }
 468
 469 static void utc_sync_agent_framework_sync_agent_set_noti_callback_p(void)
 470 {
 471         char *api_name = API_NAME_SYNC_AGENT_SET_NOTI_CALLBACK;
 472         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 473
 474         event_err = sync_agent_set_noti_callback(NOTI_NUM, _noti_cb, NULL);
 475         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 476                 dts_pass(api_name);
 477         } else {
 478                 dts_message(api_name, "sync_agent_set_noti_callback : %d", event_err);
 479                 dts_fail(api_name);
 480         }
 481 }
 482
 483 static void utc_sync_agent_framework_sync_agent_clean_event_handler_p(void)
 484 {
 485         char *api_name = API_NAME_SYNC_AGENT_CLEAN_EVENT_HANDLER;
 486         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 487
 488         event_err = sync_agent_clean_event_handler();
 489         if (event_err == SYNC_AGENT_EVENT_SUCCESS) {
 490                 dts_pass(api_name);
 491         } else {
 492                 dts_message(api_name, "sync_agent_clean_event_handler : %d", event_err);
 493                 dts_fail(api_name);
 494         }
 495 }
 496
 497 static int _event_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 498 {
 499         g_print("start event callback \n");
 500
 501         char *api_name = API_NAME_EVENT_CB;
 502         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 503         int event_int_data = 0;
 504         char *event_char_data = NULL;
 505         int event_result = 1;
 506
 507         sync_agent_get_event_data_param(request, &event_int_data);
 508         sync_agent_get_event_data_param(request, &event_char_data);
 509
 510         g_print("%s : received event data\n", __func__);
 511         dts_message(api_name, "sync_agent_get_event_data_param (int) : %d", event_int_data);
 512         dts_message(api_name, "sync_agent_get_event_data_param (char) : %s", event_char_data);
 513
 514         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 515
 516         g_print("%s : event response\n", __func__);
 517         dts_message(api_name, "sync_agent_append_event_data_param (int) : %d", event_result);
 518
 519         return 1;
 520 }
 521
 522 static sync_agent_event_ipc_cancel_e _cancel_cb(void *user_data)
 523 {
 524         g_print("start cancel callback \n");
 525
 526         char *api_name = API_NAME_CANCEL_CB;
 527
 528         sync_agent_ec_boolean cancel_flag = sync_agent_check_cancel_flag();
 529         sync_agent_event_ipc_cancel_e result_cancel;
 530
 531         if (cancel_flag == 0)
 532                 result_cancel = SYNC_AGENT_EVENT_IPC_CANCEL_UN_NEED_CANCEL;
 533         else
 534                 result_cancel = SYNC_AGENT_EVENT_IPC_CANCEL_NEED_CANCEL;
 535
 536         dts_message(api_name, "cancel result : %d", result_cancel);
 537
 538         return result_cancel;
 539 }
 540
 541 static int _noti_cb(sync_agent_event_data_s * noti, void *user_data)
 542 {
 543         g_print("start noti callback \n");
 544
 545         char *api_name = API_NAME_NOTI_CB;
 546         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 547         int noti_int_data = 0;
 548         char *noti_char_data = NULL;
 549
 550         sync_agent_get_event_data_param(noti, &noti_int_data);
 551         sync_agent_get_event_data_param(noti, &noti_char_data);
 552
 553         g_print("%s : received event data\n", __func__);
 554         dts_message(api_name, "sync_agent_get_event_data_param (int) : %d", noti_int_data);
 555         dts_message(api_name, "sync_agent_get_event_data_param (char) : %s", noti_char_data);
 556
 557         event_err = sync_agent_stop_noti_listener();
 558         if (event_err != SYNC_AGENT_EVENT_SUCCESS) {
 559                 dts_message(api_name, "sync_agent_run_noti_listener : %d", event_err);
 560 //              dts_fail(api_name);
 561         }
 562
 563         sync_agent_stop_main_loop(1);
 564
 565         return 1;
 566 }