src/recorder.c

   1 /*
   2 * Copyright (c) 2011 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 <string.h>
  20 #include <camera_internal.h>
  21 #include <recorder.h>
  22 #include <sound_manager.h>
  23 #include <sound_manager_internal.h>
  24 #include <storage.h>
  25 #include <storage-internal.h>
  26 #include <muse_recorder.h>
  27 #include <muse_recorder_msg.h>
  28 #include <muse_core.h>
  29 #include <muse_client.h>
  30 #include <recorder_private.h>
  31 #include <gio/gio.h>
  32 #include <dlog.h>
  33 #include <tzplatform_config.h>
  34
  35 #ifdef LOG_TAG
  36 #undef LOG_TAG
  37 #endif
  38 #define LOG_TAG "TIZEN_N_RECORDER"
  39
  40 /* for device changed callback */
  41 static GMutex g_rec_dev_state_changed_cb_lock;
  42 static GList *g_rec_dev_state_changed_cb_list;
  43 static int g_rec_dev_state_changed_cb_id;
  44 static GDBusConnection *g_rec_dev_state_changed_cb_conn;
  45 static guint g_rec_dev_state_changed_cb_subscribe_id;
  46 static GMutex g_rec_idle_event_lock;
  47
  48
  49
  50 static void __recorder_update_api_waiting(recorder_cb_info_s *cb_info, int api, int value)
  51 {
  52         if (!cb_info ||
  53                 api < 0 || api >= MUSE_RECORDER_API_MAX) {
  54                 LOGE("invalid param %p %d", cb_info, api);
  55                 return;
  56         }
  57
  58         g_mutex_lock(&(cb_info->api_mutex[api]));
  59         cb_info->api_waiting[api] += value;
  60         g_mutex_unlock(&(cb_info->api_mutex[api]));
  61
  62         /*LOGD("api %d, value %d, waiting %d",
  63                 api, value, cb_info->api_waiting[api]);*/
  64
  65         return;
  66 }
  67
  68
  69 static void __recorder_device_state_changed_cb(GDBusConnection *connection,
  70         const gchar *sender_name, const gchar *object_path, const gchar *interface_name,
  71         const gchar *signal_name, GVariant *param, gpointer user_data)
  72 {
  73         int value = 0;
  74         recorder_type_e type = RECORDER_TYPE_AUDIO;
  75         recorder_device_state_e state = RECORDER_DEVICE_STATE_IDLE;
  76         GList *tmp_list = NULL;
  77         recorder_cb_info *info = NULL;
  78
  79         g_mutex_lock(&g_rec_dev_state_changed_cb_lock);
  80
  81         if (!g_rec_dev_state_changed_cb_list || !param) {
  82                 LOGW("no callback or NULL param %p", param);
  83                 goto _DONE;
  84         }
  85
  86         /* get device type and state */
  87         g_variant_get(param, "(i)", &value);
  88
  89         type = value >> 16;
  90         state = 0x0000ffff & value;
  91
  92         LOGD("type %d, state %d", type, state);
  93
  94         tmp_list = g_rec_dev_state_changed_cb_list;
  95
  96         do {
  97                 info = (recorder_cb_info *)tmp_list->data;
  98
  99                 if (info) {
 100                         if (info->callback) {
 101                                 LOGD("start id[%d] callback", info->id);
 102                                 ((recorder_device_state_changed_cb)info->callback)(type, state, info->user_data);
 103                                 LOGD("returned id[%d] callback", info->id);
 104                         } else {
 105                                 LOGW("NULL callback for id %d", info->id);
 106                         }
 107                 }
 108
 109                 tmp_list = tmp_list->next;
 110         } while (tmp_list);
 111
 112 _DONE:
 113         g_mutex_unlock(&g_rec_dev_state_changed_cb_lock);
 114
 115         return;
 116 }
 117
 118
 119 static int _recorder_import_tbm_key(tbm_bufmgr bufmgr, unsigned int tbm_key, tbm_bo *bo, tbm_bo_handle *bo_handle)
 120 {
 121         tbm_bo tmp_bo = NULL;
 122         tbm_bo_handle tmp_bo_handle = {NULL, };
 123
 124         if (bufmgr == NULL || bo == NULL || bo_handle == NULL || tbm_key == 0) {
 125                 LOGE("invalid parameter - bufmgr %p, bo %p, bo_handle %p, key %d",
 126                      bufmgr, bo, bo_handle, tbm_key);
 127                 return false;
 128         }
 129
 130         tmp_bo = tbm_bo_import(bufmgr, tbm_key);
 131         if (tmp_bo == NULL) {
 132                 LOGE("bo import failed - bufmgr %p, key %d", bufmgr, tbm_key);
 133                 return false;
 134         }
 135
 136         tmp_bo_handle = tbm_bo_map(tmp_bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
 137         if (tmp_bo_handle.ptr == NULL) {
 138                 LOGE("bo map failed %p", tmp_bo);
 139                 tbm_bo_unref(tmp_bo);
 140                 tmp_bo = NULL;
 141                 return false;
 142         }
 143
 144         /* set bo and bo_handle */
 145         *bo = tmp_bo;
 146         *bo_handle = tmp_bo_handle;
 147
 148         return true;
 149 }
 150
 151 static void _recorder_release_imported_bo(tbm_bo *bo)
 152 {
 153         if (bo == NULL || *bo == NULL) {
 154                 LOGW("NULL bo");
 155                 return;
 156         }
 157
 158         tbm_bo_unmap(*bo);
 159         tbm_bo_unref(*bo);
 160         *bo = NULL;
 161
 162         return;
 163 }
 164
 165 static void _recorder_client_user_callback(recorder_cb_info_s *cb_info, char *recv_msg, muse_recorder_event_e event)
 166 {
 167         if (recv_msg == NULL || event >= MUSE_RECORDER_EVENT_TYPE_NUM) {
 168                 LOGE("invalid parameter - recorder msg %p, event %d", recv_msg, event);
 169                 return;
 170         }
 171
 172         /*LOGD("get recorder msg %s, event %d", recv_msg, event);*/
 173
 174         g_mutex_lock(&cb_info->user_cb_mutex[event]);
 175
 176         if (cb_info->user_cb[event] == NULL) {
 177                 if (event != MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM &&
 178                         event != MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM) {
 179                         g_mutex_unlock(&cb_info->user_cb_mutex[event]);
 180                         LOGW("NULL callback for event %d, return here", event);
 181                         return;
 182                 } else {
 183                         LOGW("NULL callback for event %d, NOT return here", event);
 184                 }
 185         }
 186
 187         switch (event) {
 188         case MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE:
 189                 {
 190                         int previous = 0;
 191                         int current = 0;
 192                         int by_policy = 0;
 193
 194                         muse_recorder_msg_get(previous, recv_msg);
 195                         muse_recorder_msg_get(current, recv_msg);
 196                         muse_recorder_msg_get(by_policy, recv_msg);
 197
 198                         ((recorder_state_changed_cb)cb_info->user_cb[event])((recorder_state_e)previous,
 199                                 (recorder_state_e)current,
 200                                 (bool)by_policy,
 201                                 cb_info->user_data[event]);
 202                         break;
 203                 }
 204         case MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED:
 205                 {
 206                         int type = 0;
 207
 208                         muse_recorder_msg_get(type, recv_msg);
 209
 210                         ((recorder_recording_limit_reached_cb)cb_info->user_cb[event])((recorder_recording_limit_type_e)type,
 211                                 cb_info->user_data[event]);
 212                         break;
 213                 }
 214         case MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS:
 215                 {
 216                         int64_t cb_elapsed_time = 0;
 217                         int64_t cb_file_size = 0;
 218
 219                         muse_recorder_msg_get(cb_elapsed_time, recv_msg);
 220                         muse_recorder_msg_get(cb_file_size, recv_msg);
 221
 222                         ((recorder_recording_status_cb)cb_info->user_cb[event])((unsigned long long)cb_elapsed_time,
 223                                 (unsigned long long)cb_file_size,
 224                                 cb_info->user_data[event]);
 225                         break;
 226                 }
 227         case MUSE_RECORDER_EVENT_TYPE_INTERRUPTED:
 228                 {
 229                         int policy = 0;
 230                         int previous = 0;
 231                         int current = 0;
 232
 233                         muse_recorder_msg_get(policy, recv_msg);
 234                         muse_recorder_msg_get(previous, recv_msg);
 235                         muse_recorder_msg_get(current, recv_msg);
 236
 237                         LOGW("INTERRUPTED - policy %d, state %d -> %d", policy, previous, current);
 238
 239                         ((recorder_interrupted_cb)cb_info->user_cb[event])((recorder_policy_e)policy,
 240                                 (recorder_state_e)previous,
 241                                 (recorder_state_e)current,
 242                                 cb_info->user_data[event]);
 243                         break;
 244                 }
 245         case MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED:
 246                 {
 247                         int policy = 0;
 248                         int state = 0;
 249
 250                         muse_recorder_msg_get(policy, recv_msg);
 251                         muse_recorder_msg_get(state, recv_msg);
 252
 253                         LOGW("INTERRUPT_STARTED - policy %d, state %d", policy, state);
 254
 255                         ((recorder_interrupt_started_cb)cb_info->user_cb[event])((recorder_policy_e)policy,
 256                                 (recorder_state_e)state, cb_info->user_data[event]);
 257                 }
 258                 break;
 259         case MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM:
 260                 {
 261                         int tbm_key = 0;
 262                         int size = 0;
 263                         int format = 0;
 264                         int channel = 0;
 265                         int timestamp = 0;
 266                         tbm_bo bo = NULL;
 267                         tbm_bo_handle bo_handle = {.ptr = NULL};
 268                         char *send_msg = NULL;
 269
 270                         muse_recorder_msg_get(tbm_key, recv_msg);
 271                         if (tbm_key == 0) {
 272                                 LOGE("invalid key");
 273                                 break;
 274                         }
 275
 276                         if (cb_info->user_cb[event]) {
 277                                 if (_recorder_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
 278                                         muse_recorder_msg_get(size, recv_msg);
 279                                         muse_recorder_msg_get(format, recv_msg);
 280                                         muse_recorder_msg_get(channel, recv_msg);
 281                                         muse_recorder_msg_get(timestamp, recv_msg);
 282
 283                                         ((recorder_audio_stream_cb)cb_info->user_cb[event])((void *)bo_handle.ptr,
 284                                                 size, (audio_sample_type_e)format, channel,
 285                                                 (unsigned int)timestamp, cb_info->user_data[event]);
 286
 287                                         /* release imported bo */
 288                                         _recorder_release_imported_bo(&bo);
 289                                 } else {
 290                                         LOGE("tbm key %d import failed", tbm_key);
 291                                 }
 292                         }
 293
 294                         /* return buffer */
 295                         send_msg = muse_core_msg_new(MUSE_RECORDER_API_RETURN_BUFFER,
 296                                 MUSE_TYPE_INT, "tbm_key", tbm_key, NULL);
 297
 298                         if (muse_core_msg_send(cb_info->fd, send_msg) <= 0)
 299                                 LOGE("sending message failed");
 300
 301                         muse_core_msg_free(send_msg);
 302                         break;
 303                 }
 304         case MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM:
 305                 {
 306                         int tbm_key = 0;
 307                         int size = 0;
 308                         int64_t offset = 0;
 309
 310                         tbm_bo bo = NULL;
 311                         tbm_bo_handle bo_handle = {.ptr = NULL};
 312                         char *send_msg = NULL;
 313
 314                         muse_recorder_msg_get(tbm_key, recv_msg);
 315                         if (tbm_key == 0) {
 316                                 LOGE("invalid key");
 317                                 break;
 318                         }
 319
 320                         if (cb_info->user_cb[event]) {
 321                                 if (_recorder_import_tbm_key(cb_info->bufmgr, tbm_key, &bo, &bo_handle)) {
 322                                         muse_recorder_msg_get(size, recv_msg);
 323                                         muse_recorder_msg_get(offset, recv_msg);
 324
 325                                         ((recorder_muxed_stream_cb)cb_info->user_cb[event])((void *)bo_handle.ptr,
 326                                                 size, (unsigned long long)offset, cb_info->user_data[event]);
 327
 328                                         /* release imported bo */
 329                                         _recorder_release_imported_bo(&bo);
 330                                 } else {
 331                                         LOGE("tbm key %d import failed", tbm_key);
 332                                 }
 333                         }
 334
 335                         /* return buffer */
 336                         send_msg = muse_core_msg_new(MUSE_RECORDER_API_RETURN_BUFFER,
 337                                 MUSE_TYPE_INT, "tbm_key", tbm_key, NULL);
 338                         if (send_msg) {
 339                                 if (muse_core_msg_send(cb_info->fd, send_msg) <= 0)
 340                                         LOGE("sending message failed");
 341
 342                                 muse_core_msg_free(send_msg);
 343                                 send_msg = NULL;
 344                         } else {
 345                                 LOGE("failed to create send msg for key %d", tbm_key);
 346                         }
 347                         break;
 348                 }
 349         case MUSE_RECORDER_EVENT_TYPE_ERROR:
 350                 {
 351                         int error = 0;
 352                         int current_state = 0;
 353
 354                         muse_recorder_msg_get(error, recv_msg);
 355                         muse_recorder_msg_get(current_state, recv_msg);
 356
 357                         ((recorder_error_cb)cb_info->user_cb[event])((recorder_error_e)error,
 358                                 (recorder_state_e)current_state,
 359                                 cb_info->user_data[event]);
 360                         break;
 361                 }
 362         case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER:
 363                 {
 364                         int codec = 0;
 365
 366                         muse_recorder_msg_get(codec, recv_msg);
 367
 368                         if (((recorder_supported_audio_encoder_cb)cb_info->user_cb[event])((recorder_audio_codec_e)codec, cb_info->user_data[event]) == false) {
 369                                 cb_info->user_cb[event] = NULL;
 370                                 cb_info->user_data[event] = NULL;
 371                                 /*LOGD("stop foreach callback for SUPPORTED_AUDIO_ENCODER");*/
 372                         }
 373                         break;
 374                 }
 375         case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT:
 376                 {
 377                         int format = 0;
 378
 379                         muse_recorder_msg_get(format, recv_msg);
 380
 381                         if (((recorder_supported_file_format_cb)cb_info->user_cb[event])((recorder_file_format_e)format, cb_info->user_data[event]) == false) {
 382                                 cb_info->user_cb[event] = NULL;
 383                                 cb_info->user_data[event] = NULL;
 384                                 /*LOGD("stop foreach callback for SUPPORTED_FILE_FORMAT");*/
 385                         }
 386                         break;
 387                 }
 388         case MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER:
 389                 {
 390                         int codec = 0;
 391
 392                         muse_recorder_msg_get(codec, recv_msg);
 393
 394                         if (((recorder_supported_video_encoder_cb)cb_info->user_cb[event])((recorder_video_codec_e)codec, cb_info->user_data[event]) == false) {
 395                                 cb_info->user_cb[event] = NULL;
 396                                 cb_info->user_data[event] = NULL;
 397                                 /*LOGD("stop foreach callback for SUPPORTED_VIDEO_ENCODER");*/
 398                         }
 399                         break;
 400                 }
 401         default: /* MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION */
 402                 {
 403                         int width = 0;
 404                         int height = 0;
 405
 406                         muse_recorder_msg_get(width, recv_msg);
 407                         muse_recorder_msg_get(height, recv_msg);
 408
 409                         if (((recorder_supported_video_resolution_cb)cb_info->user_cb[event])(width, height, cb_info->user_data[event]) == false) {
 410                                 cb_info->user_cb[event] = NULL;
 411                                 cb_info->user_data[event] = NULL;
 412                                 /*LOGD("stop foreach callback for SUPPORTED_VIDEO_RESOLUTION");*/
 413                         }
 414                         break;
 415                 }
 416         }
 417
 418         g_mutex_unlock(&cb_info->user_cb_mutex[event]);
 419
 420         return;
 421 }
 422
 423
 424 static gboolean _recorder_idle_event_callback(gpointer data)
 425 {
 426         recorder_cb_info_s *cb_info = NULL;
 427         recorder_idle_event_s *rec_idle_event = (recorder_idle_event_s *)data;
 428
 429         if (rec_idle_event == NULL) {
 430                 LOGE("rec_idle_event is NULL");
 431                 return FALSE;
 432         }
 433
 434         /* lock event */
 435         g_mutex_lock(&g_rec_idle_event_lock);
 436
 437         cb_info = rec_idle_event->cb_info;
 438         if (cb_info == NULL) {
 439                 LOGW("recorder cb_info is NULL. event %p %d", rec_idle_event, rec_idle_event->event);
 440                 g_mutex_unlock(&g_rec_idle_event_lock);
 441                 goto IDLE_EVENT_CALLBACK_DONE;
 442         }
 443
 444         /* remove event from list */
 445         if (cb_info->idle_event_list)
 446                 cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)rec_idle_event);
 447
 448         g_mutex_unlock(&g_rec_idle_event_lock);
 449
 450         /* user callback */
 451         _recorder_client_user_callback(cb_info, rec_idle_event->recv_msg, rec_idle_event->event);
 452
 453 IDLE_EVENT_CALLBACK_DONE:
 454         /* release event */
 455         g_free(rec_idle_event);
 456         rec_idle_event = NULL;
 457
 458         return FALSE;
 459 }
 460
 461
 462 static void _recorder_deactivate_idle_event_all(recorder_cb_info_s *cb_info)
 463 {
 464         recorder_idle_event_s *rec_idle_event = NULL;
 465         GList *list = NULL;
 466
 467         if (cb_info == NULL) {
 468                 LOGE("cb_info is NULL");
 469                 return;
 470         }
 471
 472         g_mutex_lock(&g_rec_idle_event_lock);
 473
 474         if (cb_info->idle_event_list == NULL) {
 475                 LOGD("No event");
 476         } else {
 477                 list = cb_info->idle_event_list;
 478
 479                 while (list) {
 480                         rec_idle_event = list->data;
 481                         list = g_list_next(list);
 482
 483                         if (!rec_idle_event) {
 484                                 LOGW("The event is NULL");
 485                                 continue;
 486                         }
 487
 488                         if (g_idle_remove_by_data(rec_idle_event)) {
 489                                 LOGW("remove idle event %p done", rec_idle_event);
 490
 491                                 cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)rec_idle_event);
 492
 493                                 g_free(rec_idle_event);
 494                                 rec_idle_event = NULL;
 495
 496                                 continue;
 497                         }
 498
 499                         LOGW("set NULL cb_info for event %p %d, it will be freed on idle callback",
 500                                 rec_idle_event, rec_idle_event->event);
 501
 502                         rec_idle_event->cb_info = NULL;
 503
 504                         cb_info->idle_event_list = g_list_remove(cb_info->idle_event_list, (gpointer)rec_idle_event);
 505                 }
 506
 507                 g_list_free(cb_info->idle_event_list);
 508                 cb_info->idle_event_list = NULL;
 509         }
 510
 511         g_mutex_unlock(&g_rec_idle_event_lock);
 512
 513         return;
 514 }
 515
 516
 517 static void __recorder_add_msg_to_queue(recorder_cb_info_s *cb_info, int api, int event, int event_class, char *msg)
 518 {
 519         recorder_message_s *rec_msg = NULL;
 520         recorder_msg_handler_info_s *msg_handler_info = NULL;
 521
 522         if (!cb_info || !msg) {
 523                 LOGE("NULL pointer %p %p", cb_info, msg);
 524                 return;
 525         }
 526
 527         rec_msg = g_new0(recorder_message_s, 1);
 528         if (!rec_msg) {
 529                 LOGE("failed to alloc rec_msg for [%s]", msg);
 530                 return;
 531         }
 532
 533         rec_msg->api = api;
 534         rec_msg->event = event;
 535         rec_msg->event_class = event_class;
 536
 537         strncpy(rec_msg->recv_msg, msg, sizeof(rec_msg->recv_msg) - 1);
 538
 539         /*LOGD("add recorder message to queue : api %d, event %d, event_class %d", api, event, event_class);*/
 540
 541         if (event == MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM)
 542                 msg_handler_info = &cb_info->audio_stream_cb_info;
 543         else if (event == MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM)
 544                 msg_handler_info = &cb_info->muxed_stream_cb_info;
 545         else
 546                 msg_handler_info = &cb_info->msg_handler_info;
 547
 548         g_mutex_lock(&msg_handler_info->mutex);
 549         g_queue_push_tail(msg_handler_info->queue, (gpointer)rec_msg);
 550         g_cond_signal(&msg_handler_info->cond);
 551         g_mutex_unlock(&msg_handler_info->mutex);
 552
 553         rec_msg = NULL;
 554
 555         return;
 556 }
 557
 558
 559 static void __recorder_get_api_operation(int api, recorder_cb_info_s *cb_info, char *msg)
 560 {
 561         if (!cb_info || !msg) {
 562                 LOGE("NULL pointer %p %p", cb_info, msg);
 563                 return;
 564         }
 565
 566         switch (api) {
 567         case MUSE_RECORDER_API_GET_STATE:
 568                 {
 569                         int get_state = 0;
 570                         muse_recorder_msg_get(get_state, msg);
 571                         cb_info->get_int_value[_RECORDER_GET_INT_STATE] = get_state;
 572                 }
 573                 break;
 574         case MUSE_RECORDER_API_GET_VIDEO_RESOLUTION:
 575                 {
 576                         int get_width = 0;
 577                         int get_height = 0;
 578                         muse_recorder_msg_get(get_width, msg);
 579                         muse_recorder_msg_get(get_height, msg);
 580                         cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] = get_width << 16;
 581                         cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] |= get_height;
 582                 }
 583                 break;
 584         case MUSE_RECORDER_API_GET_FILE_FORMAT:
 585                 {
 586                         int get_format = 0;
 587                         muse_recorder_msg_get(get_format, msg);
 588                         cb_info->get_int_value[_RECORDER_GET_INT_FILE_FORMAT] = get_format;
 589                 }
 590                 break;
 591         case MUSE_RECORDER_API_GET_AUDIO_ENCODER:
 592                 {
 593                         int get_codec = 0;
 594                         muse_recorder_msg_get(get_codec, msg);
 595                         cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER] = get_codec;
 596                 }
 597                 break;
 598         case MUSE_RECORDER_API_GET_VIDEO_ENCODER:
 599                 {
 600                         int get_codec = 0;
 601                         muse_recorder_msg_get(get_codec, msg);
 602                         cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER] = get_codec;
 603                 }
 604                 break;
 605         case MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT:
 606                 {
 607                         int get_kbyte = 0;
 608                         muse_recorder_msg_get(get_kbyte, msg);
 609                         cb_info->get_int_value[_RECORDER_GET_INT_SIZE_LIMIT] = get_kbyte;
 610                 }
 611                 break;
 612         case MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT:
 613                 {
 614                         int get_second = 0;
 615                         muse_recorder_msg_get(get_second, msg);
 616                         cb_info->get_int_value[_RECORDER_GET_INT_TIME_LIMIT] = get_second;
 617                 }
 618                 break;
 619         case MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE:
 620                 {
 621                         int get_device = 0;
 622                         muse_recorder_msg_get(get_device, msg);
 623                         cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_DEVICE] = get_device;
 624                 }
 625                 break;
 626         case MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE:
 627                 {
 628                         int get_samplerate = 0;
 629                         muse_recorder_msg_get(get_samplerate, msg);
 630                         cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_SAMPLERATE] = get_samplerate;
 631                 }
 632                 break;
 633         case MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE:
 634                 {
 635                         int get_bitrate = 0;
 636                         muse_recorder_msg_get(get_bitrate, msg);
 637                         cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER_BITRATE] = get_bitrate;
 638                 }
 639                 break;
 640         case MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE:
 641                 {
 642                         int get_bitrate = 0;
 643                         muse_recorder_msg_get(get_bitrate, msg);
 644                         cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER_BITRATE] = get_bitrate;
 645                 }
 646                 break;
 647         case MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE:
 648                 {
 649                         double get_rate = 0;
 650                         muse_recorder_msg_get_double(get_rate, msg);
 651                         cb_info->get_double_value[_RECORDER_GET_DOUBLE_RECORDING_MOTION_RATE] = get_rate;
 652                 }
 653                 break;
 654         case MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL:
 655                 {
 656                         int get_channel_count = 0;
 657                         muse_recorder_msg_get(get_channel_count, msg);
 658                         cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_CHANNEL] = get_channel_count;
 659                 }
 660                 break;
 661         case MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG:
 662                 {
 663                         int get_orientation = 0;
 664                         muse_recorder_msg_get(get_orientation, msg);
 665                         cb_info->get_int_value[_RECORDER_GET_INT_ORIENTATION_TAG] = get_orientation;
 666                 }
 667                 break;
 668         case MUSE_RECORDER_API_GET_AUDIO_LEVEL:
 669                 {
 670                         double get_level = 0.0;
 671                         muse_recorder_msg_get_double(get_level, msg);
 672                         cb_info->get_double_value[_RECORDER_GET_DOUBLE_AUDIO_LEVEL] = get_level;
 673                 }
 674                 break;
 675         case MUSE_RECORDER_API_GET_FILENAME:
 676                 {
 677                         char get_filename[MUSE_RECORDER_MSG_MAX_LENGTH] = {'\0',};
 678                         muse_recorder_msg_get_string(get_filename, msg);
 679                         if (cb_info->get_filename) {
 680                                 free(cb_info->get_filename);
 681                                 cb_info->get_filename = NULL;
 682                         }
 683                         cb_info->get_filename = strdup(get_filename);
 684                 }
 685                 break;
 686         default:
 687                 break;
 688         }
 689
 690         return;
 691 }
 692
 693
 694 static void __recorder_process_msg(recorder_cb_info_s *cb_info, char *msg)
 695 {
 696         int ret = RECORDER_ERROR_NONE;
 697         int api = -1;
 698         int api_class = -1;
 699         int event = -1;
 700         int event_class = -1;
 701
 702         if (!cb_info || !msg) {
 703                 LOGE("invalid ptr %p %p", cb_info, msg);
 704                 return;
 705         }
 706
 707         /*LOGD("msg [%s]", msg);*/
 708
 709         if (!muse_recorder_msg_get(api, msg)) {
 710                 LOGE("failed to get recorder api");
 711                 return;
 712         }
 713
 714         if (api == MUSE_RECORDER_CB_EVENT) {
 715                 if (!muse_recorder_msg_get(event, msg) ||
 716                         !muse_recorder_msg_get(event_class, msg)) {
 717                         LOGE("failed to get event or event_class [%s]", msg);
 718                         return;
 719                 }
 720         } else {
 721                 if (!muse_recorder_msg_get(api_class, msg)) {
 722                         LOGE("failed to get api_class [%s]", msg);
 723                         return;
 724                 }
 725         }
 726
 727         if (api_class == MUSE_RECORDER_API_CLASS_IMMEDIATE) {
 728                 if (api >= MUSE_RECORDER_API_MAX) {
 729                         LOGE("invalid api %d", api);
 730                         return;
 731                 }
 732
 733                 if (!muse_recorder_msg_get(ret, msg)) {
 734                         LOGE("failed to get recorder ret");
 735                         return;
 736                 }
 737
 738                 g_mutex_lock(&cb_info->api_mutex[api]);
 739
 740                 if (api == MUSE_RECORDER_API_GET_DEVICE_STATE) {
 741                         g_atomic_int_set(&cb_info->msg_recv_running, 0);
 742                         LOGD("get device state done. close client cb handler");
 743                 } else {
 744                         switch (api) {
 745                         case MUSE_RECORDER_API_CREATE:
 746                                 if (ret != RECORDER_ERROR_NONE) {
 747                                         g_atomic_int_set(&cb_info->msg_recv_running, 0);
 748                                         LOGE("create error 0x%x. closing..", ret);
 749                                 }
 750                                 break;
 751                         case MUSE_RECORDER_API_DESTROY:
 752                                 if (ret == RECORDER_ERROR_NONE) {
 753                                         g_atomic_int_set(&cb_info->msg_recv_running, 0);
 754                                         LOGD("destroy done. closing..");
 755                                 }
 756                                 break;
 757                         default:
 758                                 __recorder_get_api_operation(api, cb_info, msg);
 759                                 break;
 760                         }
 761                 }
 762
 763                 if (cb_info->api_waiting[api] > 0) {
 764                         cb_info->api_ret[api] = ret;
 765                         cb_info->api_activating[api] = 1;
 766
 767                         g_cond_signal(&cb_info->api_cond[api]);
 768                 } else {
 769                         LOGE("no waiting for api [%d]", api);
 770                 }
 771
 772                 g_mutex_unlock(&cb_info->api_mutex[api]);
 773         } else if (api_class == MUSE_RECORDER_API_CLASS_THREAD_SUB || api == MUSE_RECORDER_CB_EVENT) {
 774                 __recorder_add_msg_to_queue(cb_info, api, event, event_class, msg);
 775         } else {
 776                 LOGW("unknown recorder api %d and api_class %d", api, api_class);
 777         }
 778
 779         return;
 780 }
 781
 782
 783 static void *_recorder_msg_handler_func(gpointer data)
 784 {
 785         int api = 0;
 786         int type = 0;
 787         recorder_message_s *rec_msg = NULL;
 788         recorder_idle_event_s *rec_idle_event = NULL;
 789         recorder_msg_handler_info_s *handler_info = (recorder_msg_handler_info_s *)data;
 790         recorder_cb_info_s *cb_info = NULL;
 791
 792         if (!handler_info || !handler_info->cb_info) {
 793                 LOGE("NULL handler %p", handler_info);
 794                 return NULL;
 795         }
 796
 797         cb_info = (recorder_cb_info_s *)handler_info->cb_info;
 798         type = handler_info->type;
 799
 800         LOGD("t:%d start", type);
 801
 802         g_mutex_lock(&handler_info->mutex);
 803
 804         while (g_atomic_int_get(&handler_info->running)) {
 805                 if (g_queue_is_empty(handler_info->queue)) {
 806                         /*LOGD("signal wait...");*/
 807                         g_cond_wait(&handler_info->cond, &handler_info->mutex);
 808                         /*LOGD("signal received");*/
 809
 810                         if (g_atomic_int_get(&handler_info->running) == 0) {
 811                                 LOGD("stop event thread");
 812                                 break;
 813                         }
 814                 }
 815
 816                 rec_msg = (recorder_message_s *)g_queue_pop_head(handler_info->queue);
 817                 g_mutex_unlock(&handler_info->mutex);
 818                 if (rec_msg == NULL) {
 819                         LOGE("NULL message");
 820                         g_mutex_lock(&handler_info->mutex);
 821                         continue;
 822                 }
 823
 824                 api = rec_msg->api;
 825
 826                 if (api < MUSE_RECORDER_API_MAX) {
 827                         int ret = 0;
 828
 829                         g_mutex_lock(&cb_info->api_mutex[api]);
 830
 831                         if (muse_recorder_msg_get(ret, rec_msg->recv_msg)) {
 832                                 if (cb_info->api_waiting[api] > 0) {
 833                                         cb_info->api_ret[api] = ret;
 834                                         cb_info->api_activating[api] = 1;
 835
 836                                         /*LOGD("recorder api %d - return 0x%x", ret);*/
 837
 838                                         g_cond_signal(&cb_info->api_cond[api]);
 839                                 } else {
 840                                         LOGE("no waiting for api [%d]", api);
 841                                 }
 842                         } else {
 843                                 LOGE("t:%d failed to get ret for api %d, msg %s", type, api, rec_msg->recv_msg);
 844                         }
 845
 846                         g_mutex_unlock(&cb_info->api_mutex[api]);
 847                 } else if (api == MUSE_RECORDER_CB_EVENT) {
 848                         switch (rec_msg->event_class) {
 849                         case MUSE_RECORDER_EVENT_CLASS_THREAD_SUB:
 850                                 _recorder_client_user_callback(cb_info, rec_msg->recv_msg, rec_msg->event);
 851                                 break;
 852                         case MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN:
 853                                 rec_idle_event = g_new0(recorder_idle_event_s, 1);
 854                                 if (rec_idle_event == NULL) {
 855                                         LOGE("event alloc failed");
 856                                         break;
 857                                 }
 858
 859                                 rec_idle_event->event = rec_msg->event;
 860                                 rec_idle_event->cb_info = cb_info;
 861
 862                                 strncpy(rec_idle_event->recv_msg, rec_msg->recv_msg, sizeof(rec_idle_event->recv_msg) - 1);
 863
 864                                 /*LOGD("add recorder event[%d, %p] to IDLE", rec_msg->event, rec_idle_event);*/
 865
 866                                 g_mutex_lock(&g_rec_idle_event_lock);
 867                                 cb_info->idle_event_list = g_list_append(cb_info->idle_event_list, (gpointer)rec_idle_event);
 868                                 g_mutex_unlock(&g_rec_idle_event_lock);
 869
 870                                 g_idle_add_full(G_PRIORITY_DEFAULT,
 871                                         (GSourceFunc)_recorder_idle_event_callback,
 872                                         (gpointer)rec_idle_event,
 873                                         NULL);
 874                                 break;
 875                         default:
 876                                 LOGE("unknown event class %d", rec_msg->event_class);
 877                                 break;
 878                         }
 879                 } else {
 880                         LOGE("unknown api[%d] message", api);
 881                 }
 882
 883                 g_free(rec_msg);
 884                 rec_msg = NULL;
 885
 886                 g_mutex_lock(&handler_info->mutex);
 887         }
 888
 889         /* remove remained event */
 890         while (!g_queue_is_empty(handler_info->queue)) {
 891                 rec_msg = (recorder_message_s *)g_queue_pop_head(handler_info->queue);
 892                 if (rec_msg) {
 893                         LOGD("remove message %p", rec_msg);
 894                         free(rec_msg);
 895                         rec_msg = NULL;
 896                 } else {
 897                         LOGW("NULL message");
 898                 }
 899         }
 900
 901         g_mutex_unlock(&handler_info->mutex);
 902
 903         LOGD("return");
 904
 905         return NULL;
 906 }
 907
 908
 909 static void *_recorder_msg_recv_func(gpointer data)
 910 {
 911         int recv_length = 0;
 912         int single_length = 0;
 913         int remained_length = 0;
 914         char *recv_msg = NULL;
 915         char *single_msg = NULL;
 916         char *remained_msg = NULL;
 917         int num_msg = 0;
 918         int cur_pos = 0;
 919         int prev_pos = 0;
 920         recorder_cb_info_s *cb_info = (recorder_cb_info_s *)data;
 921
 922         if (cb_info == NULL) {
 923                 LOGE("cb_info NULL");
 924                 return NULL;
 925         }
 926
 927         LOGD("start");
 928
 929         single_msg = (char *)malloc(sizeof(char) * MUSE_RECORDER_MSG_MAX_LENGTH);
 930         if (single_msg == NULL) {
 931                 LOGE("single_msg malloc failed");
 932                 goto CB_HANDLER_EXIT;
 933         }
 934
 935         recv_msg = cb_info->recv_msg;
 936
 937         while (g_atomic_int_get(&cb_info->msg_recv_running)) {
 938                 recv_length = muse_core_msg_recv(cb_info->fd, recv_msg, MUSE_MSG_MAX_LENGTH);
 939                 if (recv_length <= 0) {
 940                         cb_info->is_server_connected = FALSE;
 941                         LOGE("receive msg failed - server disconnected");
 942                         break;
 943                 }
 944
 945                 recv_msg[recv_length] = '\0';
 946
 947                 cur_pos = 0;
 948                 prev_pos = 0;
 949                 num_msg = 0;
 950
 951                 /*LOGD("recv msg : %s, length : %d", recv_msg, recv_length);*/
 952
 953                 /* Need to split the combined entering msgs */
 954                 for (cur_pos = 0; cur_pos < recv_length; cur_pos++) {
 955                         if (recv_msg[cur_pos] == '}') {
 956                                 single_length = cur_pos - prev_pos + 1;
 957
 958                                 if (single_length < MUSE_RECORDER_MSG_MAX_LENGTH) {
 959                                         /* check remained msg */
 960                                         if (remained_length > 0) {
 961                                                 if (remained_msg) {
 962                                                         strncpy(single_msg, remained_msg, remained_length);
 963                                                         strncpy(single_msg + remained_length, recv_msg + prev_pos, single_length);
 964                                                         single_msg[remained_length + single_length] = '\0';
 965
 966                                                         free(remained_msg);
 967                                                         remained_msg = NULL;
 968                                                 } else {
 969                                                         strncpy(single_msg, recv_msg + prev_pos, single_length);
 970                                                         single_msg[single_length] = '\0';
 971                                                         LOGE("lost msg [%s], skip...", single_msg);
 972                                                 }
 973
 974                                                 remained_length = 0;
 975                                         } else {
 976                                                 strncpy(single_msg, recv_msg + prev_pos, single_length);
 977                                                 single_msg[single_length] = '\0';
 978                                         }
 979
 980                                         if (single_msg[0] == '{') {
 981                                                 num_msg++;
 982                                                 /*LOGD("splitted msg : [%s], Index : %d", single_msg, num_msg);*/
 983                                                 __recorder_process_msg(cb_info, single_msg);
 984                                         } else {
 985                                                 LOGE("invalid msg [%s]", single_msg);
 986                                         }
 987                                 } else {
 988                                         LOGE("too long message [len %d] skip...", single_length);
 989                                 }
 990
 991                                 prev_pos = cur_pos + 1;
 992                         }
 993                 }
 994
 995                 /* check incompleted message */
 996                 if (recv_msg[recv_length - 1] != '}') {
 997                         remained_length = recv_length - prev_pos;
 998
 999                         LOGW("incompleted message [len %d]", remained_length);
1000
1001                         if (remained_msg) {
1002                                 free(remained_msg);
1003                                 remained_msg = NULL;
1004                         }
1005
1006                         remained_msg = (char *)malloc(remained_length + 1);
1007                         if (remained_msg) {
1008                                 strncpy(remained_msg, recv_msg + prev_pos, remained_length);
1009                                 remained_msg[remained_length] = '\0';
1010                         } else {
1011                                 LOGE("failed to alloc for remained msg");
1012                         }
1013                 } else {
1014                         remained_length = 0;
1015                 }
1016         }
1017
1018         LOGD("client cb exit - server connected %d", cb_info->is_server_connected);
1019
1020         if (!cb_info->is_server_connected) {
1021                 /* send error msg for server disconnection */
1022                 char *error_msg = muse_core_msg_new(MUSE_RECORDER_CB_EVENT,
1023                         MUSE_TYPE_INT, "error", RECORDER_ERROR_SERVICE_DISCONNECTED,
1024                         MUSE_TYPE_INT, "current_state", RECORDER_STATE_NONE,
1025                         NULL);
1026
1027                 if (!error_msg) {
1028                         LOGE("error_msg failed");
1029                         goto CB_HANDLER_EXIT;
1030                 }
1031
1032                 LOGE("add error msg for service disconnection done");
1033
1034                 __recorder_add_msg_to_queue(cb_info,
1035                         MUSE_RECORDER_CB_EVENT,
1036                         MUSE_RECORDER_EVENT_TYPE_ERROR,
1037                         MUSE_RECORDER_EVENT_CLASS_THREAD_MAIN,
1038                         error_msg);
1039
1040                 muse_core_msg_free(error_msg);
1041                 error_msg = NULL;
1042
1043                 LOGE("add error msg for service disconnection done");
1044         }
1045
1046 CB_HANDLER_EXIT:
1047         if (single_msg) {
1048                 free(single_msg);
1049                 single_msg = NULL;
1050         }
1051
1052         if (remained_msg) {
1053                 free(remained_msg);
1054                 remained_msg = NULL;
1055         }
1056
1057         return NULL;
1058 }
1059
1060
1061 static bool __create_msg_handler_thread(recorder_msg_handler_info_s *handler_info,
1062         int type, const char *thread_name, recorder_cb_info_s *cb_info)
1063 {
1064         if (!handler_info || !thread_name || !cb_info) {
1065                 LOGE("t:%d NULL %p %p %p",
1066                         type, handler_info, thread_name, cb_info);
1067                 return false;
1068         }
1069
1070         LOGD("t:%d", type);
1071
1072         handler_info->type = type;
1073         handler_info->queue = g_queue_new();
1074         if (handler_info->queue == NULL) {
1075                 LOGE("t:%d queue failed", type);
1076                 return false;
1077         }
1078
1079         g_mutex_init(&handler_info->mutex);
1080         g_cond_init(&handler_info->cond);
1081
1082         handler_info->cb_info = (void *)cb_info;
1083         g_atomic_int_set(&handler_info->running, 1);
1084
1085         handler_info->thread = g_thread_try_new(thread_name,
1086                 _recorder_msg_handler_func, (gpointer)handler_info, NULL);
1087         if (handler_info->thread == NULL) {
1088                 LOGE("t:%d thread failed", type);
1089
1090                 g_mutex_clear(&handler_info->mutex);
1091                 g_cond_clear(&handler_info->cond);
1092                 g_queue_free(handler_info->queue);
1093                 handler_info->queue = NULL;
1094
1095                 return false;
1096         }
1097
1098         LOGD("t:%d done", type);
1099
1100         return true;
1101 }
1102
1103
1104 static void __destroy_msg_handler_thread(recorder_msg_handler_info_s *handler_info)
1105 {
1106         int type = 0;
1107
1108         if (!handler_info) {
1109                 LOGE("NULL handler");
1110                 return;
1111         }
1112
1113         if (!handler_info->thread) {
1114                 LOGW("thread is not created");
1115                 return;
1116         }
1117
1118         type = handler_info->type;
1119
1120         LOGD("t:%d thread %p", type, handler_info->thread);
1121
1122         g_mutex_lock(&handler_info->mutex);
1123         g_atomic_int_set(&handler_info->running, 0);
1124         g_cond_signal(&handler_info->cond);
1125         g_mutex_unlock(&handler_info->mutex);
1126
1127         g_thread_join(handler_info->thread);
1128         handler_info->thread = NULL;
1129
1130         g_mutex_clear(&handler_info->mutex);
1131         g_cond_clear(&handler_info->cond);
1132         g_queue_free(handler_info->queue);
1133         handler_info->queue = NULL;
1134
1135         LOGD("t:%d done", type);
1136
1137         return;
1138 }
1139
1140
1141 static recorder_cb_info_s *_recorder_client_callback_new(gint sockfd)
1142 {
1143         recorder_cb_info_s *cb_info = NULL;
1144         gint i = 0;
1145
1146         g_return_val_if_fail(sockfd > 0, NULL);
1147
1148         cb_info = g_new0(recorder_cb_info_s, 1);
1149         if (cb_info == NULL) {
1150                 LOGE("cb_info failed");
1151                 goto ErrorExit;
1152         }
1153
1154         cb_info->api_waiting[MUSE_RECORDER_API_CREATE] = 1;
1155
1156         for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
1157                 g_mutex_init(&cb_info->api_mutex[i]);
1158                 g_cond_init(&cb_info->api_cond[i]);
1159         }
1160
1161         for (i = 0 ; i < MUSE_RECORDER_EVENT_TYPE_NUM ; i++)
1162                 g_mutex_init(&cb_info->user_cb_mutex[i]);
1163
1164         /* message handler thread */
1165         if (!__create_msg_handler_thread(&cb_info->msg_handler_info,
1166                 _RECORDER_MESSAGE_HANDLER_TYPE_GENERAL, "recorder_msg_handler", cb_info)) {
1167                 LOGE("msg_handler_info failed");
1168                 goto ErrorExit;
1169         }
1170
1171         /* message handler thread for audio stream callback */
1172         if (!__create_msg_handler_thread(&cb_info->audio_stream_cb_info,
1173                 _RECORDER_MESSAGE_HANDLER_TYPE_AUDIO_STREAM_CB, "recorder_msg_handler:audio_stream_cb", cb_info)) {
1174                 LOGE("audio_stream_cb_info failed");
1175                 goto ErrorExit;
1176         }
1177
1178         /* message handler thread for muxed stream callback */
1179         if (!__create_msg_handler_thread(&cb_info->muxed_stream_cb_info,
1180                 _RECORDER_MESSAGE_HANDLER_TYPE_MUXED_STREAM_CB, "recorder_msg_handler:muxed_stream_cb", cb_info)) {
1181                 LOGE("muxed_stream_cb_info failed");
1182                 goto ErrorExit;
1183         }
1184
1185         cb_info->fd = sockfd;
1186
1187         /* message receive thread */
1188         g_atomic_int_set(&cb_info->msg_recv_running, 1);
1189         cb_info->msg_recv_thread = g_thread_try_new("recorder_msg_recv",
1190                 _recorder_msg_recv_func, (gpointer)cb_info, NULL);
1191         if (cb_info->msg_recv_thread == NULL) {
1192                 LOGE("message receive thread creation failed");
1193                 goto ErrorExit;
1194         }
1195
1196         cb_info->is_server_connected = TRUE;
1197
1198         return cb_info;
1199
1200 ErrorExit:
1201         if (cb_info) {
1202                 __destroy_msg_handler_thread(&cb_info->msg_handler_info);
1203                 __destroy_msg_handler_thread(&cb_info->audio_stream_cb_info);
1204                 __destroy_msg_handler_thread(&cb_info->muxed_stream_cb_info);
1205
1206                 for (i = 0 ; i < MUSE_RECORDER_EVENT_TYPE_NUM ; i++)
1207                         g_mutex_clear(&cb_info->user_cb_mutex[i]);
1208
1209                 for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
1210                         g_mutex_clear(&cb_info->api_mutex[i]);
1211                         g_cond_clear(&cb_info->api_cond[i]);
1212                 }
1213
1214                 g_free(cb_info);
1215                 cb_info = NULL;
1216         }
1217
1218         return NULL;
1219 }
1220
1221 static int _recorder_client_wait_for_cb_return(muse_recorder_api_e api, recorder_cb_info_s *cb_info, int time_out)
1222 {
1223         int ret = RECORDER_ERROR_NONE;
1224         gint64 end_time;
1225
1226         /*LOGD("Enter api : %d", api);*/
1227
1228         if (!cb_info->is_server_connected) {
1229                 LOGE("server is disconnected");
1230                 return RECORDER_ERROR_SERVICE_DISCONNECTED;
1231         }
1232
1233         g_mutex_lock(&(cb_info->api_mutex[api]));
1234
1235         if (cb_info->api_activating[api] == 0) {
1236                 if (time_out == RECORDER_CB_NO_TIMEOUT) {
1237                         LOGW("wait for api %d", api);
1238                         g_cond_wait(&(cb_info->api_cond[api]), &(cb_info->api_mutex[api]));
1239                         ret = cb_info->api_ret[api];
1240                         cb_info->api_activating[api] = 0;
1241                         LOGW("api %d returned 0x%x", api, ret);
1242                 } else {
1243                         end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND;
1244                         if (g_cond_wait_until(&(cb_info->api_cond[api]), &(cb_info->api_mutex[api]), end_time)) {
1245                                 ret = cb_info->api_ret[api];
1246                                 cb_info->api_activating[api] = 0;
1247                                 /*LOGD("return value : 0x%x", ret);*/
1248                         } else {
1249                                 ret = RECORDER_ERROR_INVALID_OPERATION;
1250                                 LOGE("api %d was TIMED OUT!", api);
1251                         }
1252                 }
1253         } else {
1254                 ret = cb_info->api_ret[api];
1255                 cb_info->api_activating[api] = 0;
1256
1257                 /*LOGD("condition is already checked for the api[%d], return[0x%x]", api, ret);*/
1258         }
1259
1260         if (ret != RECORDER_ERROR_NONE)
1261                 LOGE("ERROR : api %d - ret 0x%x", api, ret);
1262
1263         g_mutex_unlock(&(cb_info->api_mutex[api]));
1264
1265         return ret;
1266 }
1267
1268
1269 static int _recorder_msg_send(int api, recorder_cb_info_s *cb_info, int *ret, int timeout)
1270 {
1271         int send_ret = 0;
1272         char *msg = NULL;
1273
1274         if (!cb_info || !ret) {
1275                 LOGE("invalid pointer for api %d - %p %p", api, cb_info, ret);
1276                 return RECORDER_ERROR_INVALID_PARAMETER;
1277         }
1278
1279         msg = muse_core_msg_new(api, NULL);
1280         if (!msg) {
1281                 LOGE("msg creation failed: api %d", api);
1282                 return RECORDER_ERROR_OUT_OF_MEMORY;
1283         }
1284
1285         /*LOGD("send msg %s", msg);*/
1286
1287         if (cb_info->is_server_connected) {
1288                 __recorder_update_api_waiting(cb_info, api, 1);
1289                 send_ret = muse_core_msg_send(cb_info->fd, msg);
1290         }
1291
1292         if (send_ret < 0) {
1293                 LOGE("message send failed");
1294                 *ret = RECORDER_ERROR_INVALID_OPERATION;
1295         } else {
1296                 *ret = _recorder_client_wait_for_cb_return(api, cb_info, timeout);
1297         }
1298
1299         __recorder_update_api_waiting(cb_info, api, -1);
1300
1301         muse_core_msg_free(msg);
1302
1303         return RECORDER_ERROR_NONE;
1304 }
1305
1306
1307 static int _recorder_msg_send_param1(int api, recorder_cb_info_s *cb_info, int *ret, recorder_msg_param *param)
1308 {
1309         int send_ret = 0;
1310         char *msg = NULL;
1311
1312         if (!cb_info || !ret || !param) {
1313                 LOGE("invalid pointer for api %d - %p %p %p", api, cb_info, ret, param);
1314                 return RECORDER_ERROR_INVALID_PARAMETER;
1315         }
1316
1317         /*LOGD("type %d, name %s", param->type, param->name);*/
1318
1319         switch (param->type) {
1320         case MUSE_TYPE_INT:
1321                 msg = muse_core_msg_new(api, param->type, param->name, param->value.value_INT, NULL);
1322                 break;
1323         case MUSE_TYPE_DOUBLE:
1324                 msg = muse_core_msg_new(api, param->type, param->name, param->value.value_DOUBLE, NULL);
1325                 break;
1326         case MUSE_TYPE_STRING:
1327                 msg = muse_core_msg_new(api, param->type, param->name, param->value.value_STRING, NULL);
1328                 break;
1329         default:
1330                 LOGE("unknown type %d", param->type);
1331                 break;
1332         }
1333
1334         if (!msg) {
1335                 LOGE("msg creation failed: api %d, type %d, param name %s",
1336                         api, param->type, param->name);
1337                 return RECORDER_ERROR_OUT_OF_MEMORY;
1338         }
1339
1340         /*LOGD("send msg %s", msg);*/
1341
1342         if (cb_info->is_server_connected) {
1343                 __recorder_update_api_waiting(cb_info, api, 1);
1344
1345                 send_ret = muse_core_msg_send(cb_info->fd, msg);
1346         }
1347
1348         if (send_ret < 0) {
1349                 LOGE("message send failed");
1350                 *ret = RECORDER_ERROR_INVALID_OPERATION;
1351         } else {
1352                 *ret = _recorder_client_wait_for_cb_return(api, cb_info, RECORDER_CB_TIMEOUT);
1353         }
1354
1355         __recorder_update_api_waiting(cb_info, api, -1);
1356
1357         muse_core_msg_free(msg);
1358
1359         return RECORDER_ERROR_NONE;
1360 }
1361
1362
1363 static void _recorder_client_callback_destroy(recorder_cb_info_s *cb_info)
1364 {
1365         gint i = 0;
1366
1367         g_return_if_fail(cb_info != NULL);
1368
1369         LOGD("MSG receive thread[%p] destroy", cb_info->msg_recv_thread);
1370
1371         g_thread_join(cb_info->msg_recv_thread);
1372         cb_info->msg_recv_thread = NULL;
1373
1374         LOGD("msg_recv thread removed");
1375
1376         __destroy_msg_handler_thread(&cb_info->msg_handler_info);
1377         __destroy_msg_handler_thread(&cb_info->audio_stream_cb_info);
1378         __destroy_msg_handler_thread(&cb_info->muxed_stream_cb_info);
1379
1380         for (i = 0 ; i < MUSE_RECORDER_EVENT_TYPE_NUM ; i++)
1381                 g_mutex_clear(&cb_info->user_cb_mutex[i]);
1382
1383         for (i = 0 ; i < MUSE_RECORDER_API_MAX ; i++) {
1384                 g_mutex_clear(&cb_info->api_mutex[i]);
1385                 g_cond_clear(&cb_info->api_cond[i]);
1386         }
1387
1388         if (cb_info->fd > -1) {
1389                 muse_client_close(cb_info->fd);
1390                 cb_info->fd = -1;
1391         }
1392
1393         if (cb_info->bufmgr) {
1394                 tbm_bufmgr_deinit(cb_info->bufmgr);
1395                 cb_info->bufmgr = NULL;
1396         }
1397         if (cb_info->get_filename) {
1398                 free(cb_info->get_filename);
1399                 cb_info->get_filename = NULL;
1400         }
1401
1402         g_free(cb_info);
1403         cb_info = NULL;
1404
1405         return;
1406 }
1407
1408
1409 static int _recorder_storage_device_supported_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
1410 {
1411         char **root_directory = (char **)user_data;
1412
1413         if (root_directory == NULL) {
1414                 LOGE("user data is NULL");
1415                 return false;
1416         }
1417
1418         LOGD("storage id %d, type %d, state %d, path %s",
1419                 storage_id, type, state, path ? path : "NULL");
1420
1421         if (type == STORAGE_TYPE_INTERNAL && path) {
1422                 if (*root_directory) {
1423                         free(*root_directory);
1424                         *root_directory = NULL;
1425                 }
1426
1427                 *root_directory = strdup(path);
1428                 if (*root_directory) {
1429                         LOGD("get root directory %s", *root_directory);
1430                         return false;
1431                 } else {
1432                         LOGE("strdup %s failed", path);
1433                 }
1434         }
1435
1436         return true;
1437 }
1438
1439 static int _recorder_client_get_root_directory(char **root_directory)
1440 {
1441         int ret = STORAGE_ERROR_NONE;
1442
1443         if (root_directory == NULL) {
1444                 LOGE("user data is NULL");
1445                 return false;
1446         }
1447
1448         ret = storage_foreach_device_supported((storage_device_supported_cb)_recorder_storage_device_supported_cb, root_directory);
1449         if (ret != STORAGE_ERROR_NONE) {
1450                 LOGE("storage_foreach_device_supported failed 0x%x", ret);
1451                 return false;
1452         }
1453
1454         return true;
1455 }
1456
1457 static int _recorder_create_common(recorder_h *recorder, muse_recorder_type_e type, camera_h camera)
1458 {
1459         int ret = RECORDER_ERROR_NONE;
1460         int destroy_ret = RECORDER_ERROR_NONE;
1461         int sock_fd = -1;
1462         int send_ret = 0;
1463         char *send_msg = NULL;
1464         char *root_directory = NULL;
1465         intptr_t camera_handle = 0;
1466         intptr_t handle = 0;
1467         tbm_bufmgr bufmgr = NULL;
1468         recorder_cli_s *pc = NULL;
1469         recorder_msg_param param;
1470
1471         LOGD("Enter - type %d", type);
1472
1473         if (recorder == NULL) {
1474                 LOGE("NULL pointer for recorder handle");
1475                 return RECORDER_ERROR_INVALID_PARAMETER;
1476         }
1477
1478         if (type == MUSE_RECORDER_TYPE_VIDEO && camera == NULL) {
1479                 LOGE("NULL pointer for camera handle on video recorder mode");
1480                 return RECORDER_ERROR_INVALID_PARAMETER;
1481         }
1482
1483         bufmgr = tbm_bufmgr_init(-1);
1484         if (bufmgr == NULL) {
1485                 LOGE("get tbm bufmgr failed");
1486                 return RECORDER_ERROR_INVALID_OPERATION;
1487         }
1488
1489         pc = g_new0(recorder_cli_s, 1);
1490         if (pc == NULL) {
1491                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
1492                 goto _ERR_RECORDER_EXIT;
1493         }
1494
1495         sock_fd = muse_client_new();
1496         if (sock_fd < 0) {
1497                 LOGE("muse_client_new failed - returned fd %d", sock_fd);
1498                 ret = RECORDER_ERROR_INVALID_OPERATION;
1499                 goto _ERR_RECORDER_EXIT;
1500         }
1501
1502         if (type == MUSE_RECORDER_TYPE_AUDIO) {
1503                 send_msg = muse_core_msg_new(MUSE_RECORDER_API_CREATE,
1504                         MUSE_TYPE_INT, "module", MUSE_RECORDER,
1505                         MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_AUDIO,
1506                         MUSE_TYPE_INT, "pid", getpid(),
1507                         NULL);
1508         } else {
1509                 pc->camera = camera;
1510                 camera_handle = (intptr_t)((camera_cli_s *)camera)->remote_handle;
1511                 send_msg = muse_core_msg_new(MUSE_RECORDER_API_CREATE,
1512                         MUSE_TYPE_INT, "module", MUSE_RECORDER,
1513                         MUSE_TYPE_INT, PARAM_RECORDER_TYPE, MUSE_RECORDER_TYPE_VIDEO,
1514                         MUSE_TYPE_INT, "pid", getpid(),
1515                         MUSE_TYPE_POINTER, "camera_handle", camera_handle,
1516                         NULL);
1517         }
1518
1519         if (!send_msg) {
1520                 LOGE("NULL msg");
1521                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
1522                 goto _ERR_RECORDER_EXIT;
1523         }
1524
1525         LOGD("sock_fd : %d, msg : %s", sock_fd, send_msg);
1526
1527         send_ret = muse_core_msg_send(sock_fd, send_msg);
1528
1529         muse_core_msg_free(send_msg);
1530         send_msg = NULL;
1531
1532         if (send_ret < 0) {
1533                 LOGE("send msg failed %d", errno);
1534                 ret = RECORDER_ERROR_INVALID_OPERATION;
1535                 goto _ERR_RECORDER_EXIT;
1536         }
1537
1538         pc->cb_info = _recorder_client_callback_new(sock_fd);
1539         if (pc->cb_info == NULL) {
1540                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
1541                 goto _ERR_RECORDER_EXIT;
1542         }
1543
1544         sock_fd = -1;
1545
1546         ret = _recorder_client_wait_for_cb_return(MUSE_RECORDER_API_CREATE, pc->cb_info, RECORDER_CB_TIMEOUT);
1547
1548         pc->cb_info->api_waiting[MUSE_RECORDER_API_CREATE] = 0;
1549
1550         if (ret != RECORDER_ERROR_NONE) {
1551                 LOGE("API_CREATE failed 0x%x", ret);
1552                 goto _ERR_RECORDER_EXIT;
1553         }
1554
1555         muse_recorder_msg_get_pointer(handle, pc->cb_info->recv_msg);
1556         if (handle == 0) {
1557                 LOGE("Receiving Handle Failed!!");
1558                 ret = RECORDER_ERROR_INVALID_OPERATION;
1559                 goto _ERR_RECORDER_AFTER_CREATE;
1560         }
1561
1562         if (!_recorder_client_get_root_directory(&root_directory) || root_directory == NULL) {
1563                 LOGE("failed to get root directory of internal storage");
1564                 ret = RECORDER_ERROR_INVALID_OPERATION;
1565                 goto _ERR_RECORDER_AFTER_CREATE;
1566         }
1567
1568         LOGD("root directory [%s]", root_directory);
1569
1570         RECORDER_MSG_PARAM_SET(param, STRING, root_directory);
1571
1572         _recorder_msg_send_param1(MUSE_RECORDER_API_ATTR_SET_ROOT_DIRECTORY, pc->cb_info, &ret, &param);
1573
1574         if (ret != RECORDER_ERROR_NONE) {
1575                 LOGE("failed to set root directory %s", root_directory);
1576                 ret = RECORDER_ERROR_INVALID_OPERATION;
1577                 goto _ERR_RECORDER_AFTER_CREATE;
1578         }
1579
1580         free(root_directory);
1581         root_directory = NULL;
1582
1583         pc->remote_handle = handle;
1584         pc->cb_info->bufmgr = bufmgr;
1585
1586         LOGD("recorder[type %d] %p create success : remote handle 0x%x",
1587                 type, pc, pc->remote_handle);
1588
1589         *recorder = (recorder_h)pc;
1590
1591         LOGD("done");
1592
1593         return RECORDER_ERROR_NONE;
1594
1595 _ERR_RECORDER_AFTER_CREATE:
1596         _recorder_msg_send(MUSE_RECORDER_API_DESTROY, pc->cb_info, &destroy_ret, RECORDER_CB_TIMEOUT);
1597         LOGE("destroy return 0x%x", destroy_ret);
1598
1599 _ERR_RECORDER_EXIT:
1600         tbm_bufmgr_deinit(bufmgr);
1601         bufmgr = NULL;
1602
1603         if (root_directory) {
1604                 free(root_directory);
1605                 root_directory = NULL;
1606         }
1607
1608         if (sock_fd > -1) {
1609                 muse_client_close(sock_fd);
1610                 sock_fd = -1;
1611         }
1612
1613         if (pc) {
1614                 if (pc->cb_info) {
1615                         _recorder_client_callback_destroy(pc->cb_info);
1616                         pc->cb_info = NULL;
1617                 }
1618                 g_free(pc);
1619                 pc = NULL;
1620         }
1621
1622         return ret;
1623 }
1624
1625
1626 int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
1627 {
1628         return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_VIDEO, camera);
1629 }
1630
1631
1632 int recorder_create_audiorecorder(recorder_h *recorder)
1633 {
1634         return _recorder_create_common(recorder, MUSE_RECORDER_TYPE_AUDIO, NULL);
1635 }
1636
1637
1638 int recorder_get_state(recorder_h recorder, recorder_state_e *state)
1639 {
1640         int ret = RECORDER_ERROR_NONE;
1641         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1642         muse_recorder_api_e api = MUSE_RECORDER_API_GET_STATE;
1643
1644         if (!pc || !pc->cb_info) {
1645                 LOGE("NULL handle");
1646                 return RECORDER_ERROR_INVALID_PARAMETER;
1647         }
1648
1649         if (state == NULL) {
1650                 LOGE("NULL pointer state");
1651                 return RECORDER_ERROR_INVALID_PARAMETER;
1652         }
1653
1654         LOGD("Enter, remote_handle : %x", pc->remote_handle);
1655
1656         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
1657
1658         if (ret == RECORDER_ERROR_NONE)
1659                 *state = (recorder_state_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_STATE];
1660
1661         LOGD("ret : 0x%x, state : %d", ret, *state);
1662
1663         return ret;
1664 }
1665
1666
1667 int recorder_destroy(recorder_h recorder)
1668 {
1669         int ret = RECORDER_ERROR_NONE;
1670         muse_recorder_api_e api = MUSE_RECORDER_API_DESTROY;
1671         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1672
1673         if (!pc || !pc->cb_info) {
1674                 LOGE("NULL handle");
1675                 return RECORDER_ERROR_INVALID_PARAMETER;
1676         }
1677
1678         LOGD("ENTER");
1679
1680         if (pc->cb_info->is_server_connected)
1681                 _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
1682         else
1683                 LOGW("server disconnected. release resource without send message.");
1684
1685         if (ret == RECORDER_ERROR_NONE) {
1686                 _recorder_deactivate_idle_event_all(pc->cb_info);
1687                 _recorder_client_callback_destroy(pc->cb_info);
1688                 g_free(pc);
1689                 pc = NULL;
1690         }
1691
1692         LOGD("ret : 0x%x", ret);
1693
1694         return ret;
1695 }
1696
1697
1698 int recorder_prepare(recorder_h recorder)
1699 {
1700         int ret = RECORDER_ERROR_NONE;
1701         muse_recorder_api_e api = MUSE_RECORDER_API_PREPARE;
1702         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1703
1704         if (!pc || !pc->cb_info) {
1705                 LOGE("NULL handle");
1706                 return RECORDER_ERROR_INVALID_PARAMETER;
1707         }
1708
1709         LOGD("ENTER");
1710
1711         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
1712
1713         LOGD("ret : 0x%x", ret);
1714
1715         if (ret == RECORDER_ERROR_NONE && pc->camera)
1716                 camera_start_evas_rendering(pc->camera);
1717
1718         return ret;
1719 }
1720
1721
1722 int recorder_unprepare(recorder_h recorder)
1723 {
1724         int ret = RECORDER_ERROR_NONE;
1725         muse_recorder_api_e api = MUSE_RECORDER_API_UNPREPARE;
1726         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1727         camera_state_e camera_state = CAMERA_STATE_NONE;
1728
1729         if (!pc || !pc->cb_info) {
1730                 LOGE("NULL handle");
1731                 return RECORDER_ERROR_INVALID_PARAMETER;
1732         }
1733
1734         LOGD("ENTER");
1735
1736         if (pc->camera) {
1737                 ret = camera_get_state(pc->camera, &camera_state);
1738                 if (ret != CAMERA_ERROR_NONE) {
1739                         LOGE("failed to get camera state 0x%x", ret);
1740                         return RECORDER_ERROR_INVALID_OPERATION;
1741                 }
1742
1743                 if (camera_state == CAMERA_STATE_PREVIEW) {
1744                         ret = camera_stop_evas_rendering(pc->camera, false);
1745                         if (ret != CAMERA_ERROR_NONE) {
1746                                 LOGE("camera_stop_evas_rendering failed 0x%x", ret);
1747                                 return RECORDER_ERROR_INVALID_OPERATION;
1748                         }
1749                 }
1750         }
1751
1752         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
1753
1754         LOGD("ret : 0x%x", ret);
1755
1756         return ret;
1757 }
1758
1759
1760 int recorder_start(recorder_h recorder)
1761 {
1762         int ret = RECORDER_ERROR_NONE;
1763         muse_recorder_api_e api = MUSE_RECORDER_API_START;
1764         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1765         recorder_state_e current_state = RECORDER_STATE_NONE;
1766
1767         if (!pc || !pc->cb_info) {
1768                 LOGE("NULL handle");
1769                 return RECORDER_ERROR_INVALID_PARAMETER;
1770         }
1771
1772         LOGD("ENTER");
1773
1774         if (pc->camera) {
1775                 ret = recorder_get_state(recorder, &current_state);
1776                 if (ret != RECORDER_ERROR_NONE) {
1777                         LOGE("failed to get current state 0x%x", ret);
1778                         return RECORDER_ERROR_INVALID_OPERATION;
1779                 }
1780
1781                 if (current_state == RECORDER_STATE_READY) {
1782                         ret = camera_stop_evas_rendering(pc->camera, true);
1783                         if (ret != CAMERA_ERROR_NONE) {
1784                                 LOGE("camera_stop_evas_rendering failed 0x%x", ret);
1785                                 return RECORDER_ERROR_INVALID_OPERATION;
1786                         }
1787                 }
1788         }
1789
1790         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_NO_TIMEOUT);
1791
1792         if (pc->camera && current_state == RECORDER_STATE_READY)
1793                 camera_start_evas_rendering(pc->camera);
1794
1795         LOGD("ret : 0x%x", ret);
1796
1797         return ret;
1798 }
1799
1800
1801 int recorder_pause(recorder_h recorder)
1802 {
1803         int ret = RECORDER_ERROR_NONE;
1804         muse_recorder_api_e api = MUSE_RECORDER_API_PAUSE;
1805         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1806
1807         if (!pc || !pc->cb_info) {
1808                 LOGE("NULL handle");
1809                 return RECORDER_ERROR_INVALID_PARAMETER;
1810         }
1811
1812         LOGD("ENTER");
1813
1814         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
1815
1816         LOGD("ret : 0x%x", ret);
1817
1818         return ret;
1819 }
1820
1821
1822 int recorder_commit(recorder_h recorder)
1823 {
1824         int ret = RECORDER_ERROR_NONE;
1825         muse_recorder_api_e api = MUSE_RECORDER_API_COMMIT;
1826         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1827         recorder_state_e current_state = RECORDER_STATE_NONE;
1828
1829         if (!pc || !pc->cb_info) {
1830                 LOGE("NULL handle");
1831                 return RECORDER_ERROR_INVALID_PARAMETER;
1832         }
1833
1834         LOGD("ENTER");
1835
1836         if (pc->camera) {
1837                 ret = recorder_get_state(recorder, &current_state);
1838                 if (ret != RECORDER_ERROR_NONE) {
1839                         LOGE("failed to get current state 0x%x", ret);
1840                         return RECORDER_ERROR_INVALID_OPERATION;
1841                 }
1842
1843                 if (current_state >= RECORDER_STATE_RECORDING) {
1844                         ret = camera_stop_evas_rendering(pc->camera, true);
1845                         if (ret != CAMERA_ERROR_NONE) {
1846                                 LOGE("camera_stop_evas_rendering failed 0x%x", ret);
1847                                 return RECORDER_ERROR_INVALID_OPERATION;
1848                         }
1849                 }
1850         }
1851
1852         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
1853
1854         if (pc->camera && current_state >= RECORDER_STATE_RECORDING)
1855                 camera_start_evas_rendering(pc->camera);
1856
1857         LOGD("ret : 0x%x", ret);
1858
1859         return ret;
1860 }
1861
1862
1863 int recorder_cancel(recorder_h recorder)
1864 {
1865         int ret = RECORDER_ERROR_NONE;
1866         muse_recorder_api_e api = MUSE_RECORDER_API_CANCEL;
1867         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1868         recorder_state_e current_state = RECORDER_STATE_NONE;
1869
1870         if (!pc || !pc->cb_info) {
1871                 LOGE("NULL handle");
1872                 return RECORDER_ERROR_INVALID_PARAMETER;
1873         }
1874
1875         LOGD("ENTER");
1876
1877         if (pc->camera) {
1878                 ret = recorder_get_state(recorder, &current_state);
1879                 if (ret != RECORDER_ERROR_NONE) {
1880                         LOGE("failed to get current state 0x%x", ret);
1881                         return RECORDER_ERROR_INVALID_OPERATION;
1882                 }
1883
1884                 if (current_state >= RECORDER_STATE_RECORDING) {
1885                         ret = camera_stop_evas_rendering(pc->camera, true);
1886                         if (ret != CAMERA_ERROR_NONE) {
1887                                 LOGE("camera_stop_evas_rendering failed 0x%x", ret);
1888                                 return RECORDER_ERROR_INVALID_OPERATION;
1889                         }
1890                 }
1891         }
1892
1893         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
1894
1895         if (pc->camera && current_state >= RECORDER_STATE_RECORDING)
1896                 camera_start_evas_rendering(pc->camera);
1897
1898         LOGD("ret : 0x%x", ret);
1899
1900         return ret;
1901 }
1902
1903
1904 int recorder_set_video_resolution(recorder_h recorder, int width, int height)
1905 {
1906         int ret = RECORDER_ERROR_NONE;
1907         int send_ret = 0;
1908         char *send_msg = NULL;
1909         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_RESOLUTION;
1910         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1911
1912         if (!pc || !pc->cb_info) {
1913                 LOGE("NULL handle");
1914                 return RECORDER_ERROR_INVALID_PARAMETER;
1915         }
1916
1917         LOGD("ENTER");
1918
1919         send_msg = muse_core_msg_new(api,
1920                 MUSE_TYPE_INT, "width", width,
1921                 MUSE_TYPE_INT, "height", height,
1922                 NULL);
1923         if (send_msg) {
1924                 if (pc->cb_info->is_server_connected) {
1925                         __recorder_update_api_waiting(pc->cb_info, api, 1);
1926
1927                         send_ret = muse_core_msg_send(pc->cb_info->fd, send_msg);
1928                 }
1929
1930                 if (send_ret < 0) {
1931                         LOGE("message send failed");
1932                         ret = RECORDER_ERROR_INVALID_OPERATION;
1933                 } else {
1934                         ret = _recorder_client_wait_for_cb_return(api, pc->cb_info, RECORDER_CB_TIMEOUT);
1935                 }
1936
1937                 __recorder_update_api_waiting(pc->cb_info, api, -1);
1938
1939                 muse_core_msg_free(send_msg);
1940         } else {
1941                 LOGE("failed to create msg");
1942                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
1943         }
1944
1945         LOGD("ret : 0x%x", ret);
1946
1947         return ret;
1948 }
1949
1950
1951 int recorder_get_video_resolution(recorder_h recorder, int *width, int *height)
1952 {
1953         int ret = RECORDER_ERROR_NONE;
1954         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_RESOLUTION;
1955         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1956
1957         if (!pc || !pc->cb_info) {
1958                 LOGE("NULL handle");
1959                 return RECORDER_ERROR_INVALID_PARAMETER;
1960         }
1961
1962         if (!width || !height) {
1963                 LOGE("NULL pointer width = [%p], height = [%p]", width, height);
1964                 return RECORDER_ERROR_INVALID_PARAMETER;
1965         }
1966
1967         LOGD("ENTER");
1968
1969         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
1970
1971         if (ret == RECORDER_ERROR_NONE) {
1972                 *width = pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION] >> 16;
1973                 *height = (0x0000ffff & pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_RESOLUTION]);
1974         }
1975
1976         LOGD("ret : 0x%x, %dx%d", ret, *width, *height);
1977
1978         return ret;
1979 }
1980
1981
1982 int recorder_foreach_supported_video_resolution(recorder_h recorder,
1983         recorder_supported_video_resolution_cb foreach_cb, void *user_data)
1984 {
1985         int ret = RECORDER_ERROR_NONE;
1986         recorder_cli_s *pc = (recorder_cli_s *)recorder;
1987         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_RESOLUTION;
1988
1989         if (!pc || !pc->cb_info || foreach_cb == NULL) {
1990                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
1991                 return RECORDER_ERROR_INVALID_PARAMETER;
1992         }
1993
1994         LOGD("Enter, handle :%x", pc->remote_handle);
1995
1996         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = foreach_cb;
1997         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_RESOLUTION] = user_data;
1998
1999         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2000
2001         LOGD("ret : 0x%x", ret);
2002
2003         return ret;
2004 }
2005
2006
2007 int recorder_get_audio_level(recorder_h recorder, double *level)
2008 {
2009         int ret = RECORDER_ERROR_NONE;
2010         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_LEVEL;
2011         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2012
2013         if (!pc || !pc->cb_info || level == NULL) {
2014                 LOGE("NULL pointer %p %p", pc, level);
2015                 return RECORDER_ERROR_INVALID_PARAMETER;
2016         }
2017
2018         LOGD("ENTER");
2019
2020         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2021
2022         if (ret == RECORDER_ERROR_NONE)
2023                 *level = pc->cb_info->get_double_value[_RECORDER_GET_DOUBLE_AUDIO_LEVEL];
2024
2025         LOGD("ret : 0x%x, level %lf", ret, *level);
2026
2027         return ret;
2028 }
2029
2030
2031 int recorder_set_filename(recorder_h recorder, const char *filename)
2032 {
2033         int ret = RECORDER_ERROR_NONE;
2034         size_t length = 0;
2035         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILENAME;
2036         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2037         recorder_msg_param param;
2038         char set_filename[RECORDER_FILENAME_MAX] = {'\0',};
2039
2040         if (!pc || !pc->cb_info) {
2041                 LOGE("NULL handle");
2042                 return RECORDER_ERROR_INVALID_PARAMETER;
2043         }
2044
2045         if (filename == NULL) {
2046                 LOGE("filename is NULL");
2047                 return RECORDER_ERROR_INVALID_PARAMETER;
2048         }
2049
2050         LOGD("ENTER [%s]", filename);
2051
2052         length = strlen(filename);
2053
2054         if (length >= RECORDER_FILENAME_MAX - 1) {
2055                 LOGE("too long file name [%d]", length);
2056                 return RECORDER_ERROR_INVALID_PARAMETER;
2057         }
2058
2059         if (storage_get_origin_internal_path(filename, RECORDER_FILENAME_MAX, set_filename) < 0) {
2060                 /* Cannot convert. Use original path. */
2061                 strncpy(set_filename, filename, length + 1);
2062                 pc->cb_info->is_filename_converted = FALSE;
2063         } else {
2064                 /* Converted. Use converted path. */
2065                 LOGD("Converted filename : %s -> %s", filename, set_filename);
2066                 pc->cb_info->is_filename_converted = TRUE;
2067         }
2068
2069         RECORDER_MSG_PARAM_SET(param, STRING, set_filename);
2070
2071         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2072
2073         LOGD("ret : 0x%x", ret);
2074
2075         return ret;
2076 }
2077
2078
2079 int recorder_get_filename(recorder_h recorder,  char **filename)
2080 {
2081         int ret = RECORDER_ERROR_NONE;
2082         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILENAME;
2083         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2084         char compat_filename[RECORDER_FILENAME_MAX] = {0, };
2085
2086         if (!pc || !pc->cb_info) {
2087                 LOGE("NULL handle");
2088                 return RECORDER_ERROR_INVALID_PARAMETER;
2089         }
2090
2091         if (filename == NULL) {
2092                 LOGE("filename is NULL");
2093                 return RECORDER_ERROR_INVALID_PARAMETER;
2094         }
2095
2096         LOGD("ENTER");
2097
2098         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2099
2100         if (ret == RECORDER_ERROR_NONE) {
2101                 if (pc->cb_info->is_filename_converted == FALSE ||
2102                         storage_get_compat_internal_path(pc->cb_info->get_filename, RECORDER_FILENAME_MAX, compat_filename) < 0) {
2103                         /* Use original path. */
2104                         *filename = pc->cb_info->get_filename;
2105                 } else {
2106                         /* Converted. Use converted path. */
2107                         LOGD("Converted filename : %s -> %s", pc->cb_info->get_filename, compat_filename);
2108                         *filename = strdup(compat_filename);
2109                         free(pc->cb_info->get_filename);
2110                 }
2111
2112                 pc->cb_info->get_filename = NULL;
2113         }
2114
2115         LOGD("ret : 0x%x, filename : [%s]", ret, (*filename) ? *filename : "NULL");
2116
2117         return ret;
2118 }
2119
2120
2121 int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
2122 {
2123         int ret = RECORDER_ERROR_NONE;
2124         int set_format = (int)format;
2125         muse_recorder_api_e api = MUSE_RECORDER_API_SET_FILE_FORMAT;
2126         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2127         recorder_msg_param param;
2128
2129         if (!pc || !pc->cb_info) {
2130                 LOGE("NULL handle");
2131                 return RECORDER_ERROR_INVALID_PARAMETER;
2132         }
2133
2134         LOGD("ENTER, set_format : %d", set_format);
2135
2136         RECORDER_MSG_PARAM_SET(param, INT, set_format);
2137
2138         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2139
2140         LOGD("ret : 0x%x", ret);
2141         return ret;
2142 }
2143
2144
2145 int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format)
2146 {
2147         int ret = RECORDER_ERROR_NONE;
2148         muse_recorder_api_e api = MUSE_RECORDER_API_GET_FILE_FORMAT;
2149         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2150
2151         if (!pc || !pc->cb_info) {
2152                 LOGE("NULL handle");
2153                 return RECORDER_ERROR_INVALID_PARAMETER;
2154         }
2155
2156         if (format == NULL) {
2157                 LOGE("NULL pointer data");
2158                 return RECORDER_ERROR_INVALID_PARAMETER;
2159         }
2160
2161         LOGD("ENTER");
2162
2163         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2164
2165         if (ret == RECORDER_ERROR_NONE)
2166                 *format = (recorder_file_format_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_FILE_FORMAT];
2167
2168         LOGD("ret : 0x%x, format %d", ret, *format);
2169
2170         return ret;
2171 }
2172
2173
2174 int recorder_set_sound_stream_info(recorder_h recorder, sound_stream_info_h stream_info)
2175 {
2176         int ret = RECORDER_ERROR_NONE;
2177         muse_recorder_api_e api = MUSE_RECORDER_API_SET_SOUND_STREAM_INFO;
2178         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2179         bool is_available = false;
2180         int stream_index = 0;
2181         char *stream_type = NULL;
2182         char *send_msg = NULL;
2183         int send_ret = 0;
2184
2185         if (!pc || !pc->cb_info || stream_info == NULL) {
2186                 LOGE("NULL handle");
2187                 return RECORDER_ERROR_INVALID_PARAMETER;
2188         }
2189
2190         LOGD("ENTER");
2191
2192         ret = sound_manager_is_available_stream_information(stream_info, NATIVE_API_RECORDER, &is_available);
2193         if (ret != SOUND_MANAGER_ERROR_NONE) {
2194                 LOGE("stream info verification failed");
2195                 return RECORDER_ERROR_INVALID_OPERATION;
2196         }
2197
2198         if (is_available == false) {
2199                 LOGE("stream information is not available");
2200                 return RECORDER_ERROR_INVALID_OPERATION;
2201         }
2202
2203         ret = sound_manager_get_type_from_stream_information(stream_info, &stream_type);
2204         ret |= sound_manager_get_index_from_stream_information(stream_info, &stream_index);
2205
2206         LOGD("sound manager return [0x%x]", ret);
2207
2208         if (ret == SOUND_MANAGER_ERROR_NONE) {
2209                 send_msg = muse_core_msg_new(api,
2210                         MUSE_TYPE_STRING, "stream_type", stream_type,
2211                         MUSE_TYPE_INT, "stream_index", stream_index,
2212                         NULL);
2213                 if (send_msg) {
2214                         if (pc->cb_info->is_server_connected) {
2215                                 __recorder_update_api_waiting(pc->cb_info, api, 1);
2216
2217                                 send_ret = muse_core_msg_send(pc->cb_info->fd, send_msg);
2218                         }
2219
2220                         if (send_ret < 0) {
2221                                 LOGE("message send failed");
2222                                 ret = RECORDER_ERROR_INVALID_OPERATION;
2223                         } else {
2224                                 ret = _recorder_client_wait_for_cb_return(api, pc->cb_info, RECORDER_CB_TIMEOUT);
2225                         }
2226
2227                         __recorder_update_api_waiting(pc->cb_info, api, -1);
2228
2229                         muse_core_msg_free(send_msg);
2230                 } else {
2231                         LOGE("failed to create msg");
2232                         ret = RECORDER_ERROR_OUT_OF_MEMORY;
2233                 }
2234         } else {
2235                 ret = RECORDER_ERROR_INVALID_OPERATION;
2236         }
2237
2238         return ret;
2239 }
2240
2241
2242 int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb callback, void *user_data)
2243 {
2244         int ret = RECORDER_ERROR_NONE;
2245         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2246         muse_recorder_api_e api = MUSE_RECORDER_API_SET_STATE_CHANGED_CB;
2247
2248         if (!pc || !pc->cb_info || callback == NULL) {
2249                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2250                 return RECORDER_ERROR_INVALID_PARAMETER;
2251         }
2252
2253         LOGD("Enter, handle :%x", pc->remote_handle);
2254
2255         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2256
2257         if (ret == RECORDER_ERROR_NONE) {
2258                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE]);
2259
2260                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
2261                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
2262
2263                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE]);
2264         }
2265
2266         LOGD("ret : 0x%x", ret);
2267
2268         return ret;
2269 }
2270
2271
2272 int recorder_unset_state_changed_cb(recorder_h recorder)
2273 {
2274         int ret = RECORDER_ERROR_NONE;
2275         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_STATE_CHANGED_CB;
2276         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2277
2278         if (!pc || !pc->cb_info) {
2279                 LOGE("NULL handle");
2280                 return RECORDER_ERROR_INVALID_PARAMETER;
2281         }
2282
2283         LOGD("ENTER");
2284
2285         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2286
2287         if (ret == RECORDER_ERROR_NONE) {
2288                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE]);
2289
2290                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = NULL;
2291                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE] = NULL;
2292
2293                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_STATE_CHANGE]);
2294         }
2295
2296         LOGD("ret : 0x%x", ret);
2297
2298         return ret;
2299 }
2300
2301
2302 int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback, void *user_data)
2303 {
2304         int ret = RECORDER_ERROR_NONE;
2305         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2306         muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPTED_CB;
2307
2308         if (!pc || !pc->cb_info || callback == NULL) {
2309                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2310                 return RECORDER_ERROR_INVALID_PARAMETER;
2311         }
2312
2313         LOGD("Enter, handle :%x", pc->remote_handle);
2314
2315         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2316
2317         if (ret == RECORDER_ERROR_NONE) {
2318                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED]);
2319
2320                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
2321                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
2322
2323                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED]);
2324         }
2325
2326         LOGD("ret : 0x%x", ret);
2327
2328         return ret;
2329 }
2330
2331
2332 int recorder_unset_interrupted_cb(recorder_h recorder)
2333 {
2334         int ret = RECORDER_ERROR_NONE;
2335         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPTED_CB;
2336         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2337
2338         if (!pc || !pc->cb_info) {
2339                 LOGE("NULL handle");
2340                 return RECORDER_ERROR_INVALID_PARAMETER;
2341         }
2342
2343         LOGD("ENTER");
2344
2345         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2346
2347         if (ret == RECORDER_ERROR_NONE) {
2348                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED]);
2349
2350                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
2351                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
2352
2353                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_INTERRUPTED]);
2354         }
2355
2356         LOGD("ret : 0x%x", ret);
2357
2358         return ret;
2359 }
2360
2361
2362 int recorder_set_interrupt_started_cb(recorder_h recorder, recorder_interrupt_started_cb callback, void *user_data)
2363 {
2364         int ret = RECORDER_ERROR_NONE;
2365         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2366         muse_recorder_api_e api = MUSE_RECORDER_API_SET_INTERRUPT_STARTED_CB;
2367
2368         if (!pc || !pc->cb_info || callback == NULL) {
2369                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2370                 return RECORDER_ERROR_INVALID_PARAMETER;
2371         }
2372
2373         LOGD("Enter, handle :%x", pc->remote_handle);
2374
2375         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2376
2377         if (ret == RECORDER_ERROR_NONE) {
2378                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED]);
2379
2380                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = callback;
2381                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = user_data;
2382
2383                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED]);
2384         }
2385
2386         LOGD("ret : 0x%x", ret);
2387
2388         return ret;
2389 }
2390
2391
2392 int recorder_unset_interrupt_started_cb(recorder_h recorder)
2393 {
2394         int ret = RECORDER_ERROR_NONE;
2395         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_INTERRUPT_STARTED_CB;
2396         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2397
2398         if (!pc || !pc->cb_info) {
2399                 LOGE("NULL handle");
2400                 return RECORDER_ERROR_INVALID_PARAMETER;
2401         }
2402
2403         LOGD("ENTER");
2404
2405         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2406
2407         if (ret == RECORDER_ERROR_NONE) {
2408                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED]);
2409
2410                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = NULL;
2411                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED] = NULL;
2412
2413                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_INTERRUPT_STARTED]);
2414         }
2415
2416         LOGD("ret : 0x%x", ret);
2417
2418         return ret;
2419 }
2420
2421
2422 int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void *user_data)
2423 {
2424         int ret = RECORDER_ERROR_NONE;
2425         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2426         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_STREAM_CB;
2427
2428         if (!pc || !pc->cb_info || callback == NULL) {
2429                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2430                 return RECORDER_ERROR_INVALID_PARAMETER;
2431         }
2432
2433         LOGD("Enter, handle :%x", pc->remote_handle);
2434
2435         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2436
2437         if (ret == RECORDER_ERROR_NONE) {
2438                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
2439
2440                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
2441                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
2442
2443                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
2444         }
2445
2446         LOGD("ret : 0x%x", ret);
2447
2448         return ret;
2449 }
2450
2451
2452 int recorder_unset_audio_stream_cb(recorder_h recorder)
2453 {
2454         int ret = RECORDER_ERROR_NONE;
2455         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_AUDIO_STREAM_CB;
2456         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2457
2458         if (!pc || !pc->cb_info) {
2459                 LOGE("NULL handle");
2460                 return RECORDER_ERROR_INVALID_PARAMETER;
2461         }
2462
2463         LOGD("ENTER");
2464
2465         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2466
2467         if (ret == RECORDER_ERROR_NONE) {
2468                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
2469
2470                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
2471                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
2472
2473                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
2474         }
2475
2476         LOGD("ret : 0x%x", ret);
2477
2478         return ret;
2479 }
2480
2481
2482 int recorder_set_muxed_stream_cb(recorder_h recorder, recorder_muxed_stream_cb callback, void *user_data)
2483 {
2484         int ret = RECORDER_ERROR_NONE;
2485         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2486         muse_recorder_api_e api = MUSE_RECORDER_API_SET_MUXED_STREAM_CB;
2487
2488         if (!pc || !pc->cb_info || !callback) {
2489                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2490                 return RECORDER_ERROR_INVALID_PARAMETER;
2491         }
2492
2493         LOGD("Enter, handle :%x", pc->remote_handle);
2494
2495         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2496
2497         if (ret == RECORDER_ERROR_NONE) {
2498                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM]);
2499
2500                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM] = callback;
2501                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM] = user_data;
2502
2503                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM]);
2504         }
2505
2506         LOGD("ret : 0x%x", ret);
2507
2508         return ret;
2509 }
2510
2511
2512 int recorder_unset_muxed_stream_cb(recorder_h recorder)
2513 {
2514         int ret = RECORDER_ERROR_NONE;
2515         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_MUXED_STREAM_CB;
2516         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2517
2518         if (!pc || !pc->cb_info) {
2519                 LOGE("NULL handle");
2520                 return RECORDER_ERROR_INVALID_PARAMETER;
2521         }
2522
2523         LOGD("ENTER");
2524
2525         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2526
2527         if (ret == RECORDER_ERROR_NONE) {
2528                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM]);
2529
2530                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM] = NULL;
2531                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM] = NULL;
2532
2533                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_MUXED_STREAM]);
2534         }
2535
2536         LOGD("ret : 0x%x", ret);
2537
2538         return ret;
2539 }
2540
2541
2542 int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void *user_data)
2543 {
2544         int ret = RECORDER_ERROR_NONE;
2545         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2546         muse_recorder_api_e api = MUSE_RECORDER_API_SET_ERROR_CB;
2547
2548         if (!pc || !pc->cb_info || callback == NULL) {
2549                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2550                 return RECORDER_ERROR_INVALID_PARAMETER;
2551         }
2552
2553         LOGD("Enter, handle :%x", pc->remote_handle);
2554
2555         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2556
2557         if (ret == RECORDER_ERROR_NONE) {
2558                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_ERROR]);
2559
2560                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_ERROR] = callback;
2561                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_ERROR] = user_data;
2562
2563                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_ERROR]);
2564         }
2565
2566         LOGD("ret : 0x%x", ret);
2567
2568         return ret;
2569 }
2570
2571
2572 int recorder_unset_error_cb(recorder_h recorder)
2573 {
2574         int ret = RECORDER_ERROR_NONE;
2575         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_ERROR_CB;
2576         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2577
2578         if (!pc || !pc->cb_info) {
2579                 LOGE("NULL handle");
2580                 return RECORDER_ERROR_INVALID_PARAMETER;
2581         }
2582
2583         LOGD("ENTER");
2584
2585         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2586
2587         if (ret == RECORDER_ERROR_NONE) {
2588                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_ERROR]);
2589
2590                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_ERROR] = NULL;
2591                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_ERROR] = NULL;
2592
2593                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_ERROR]);
2594         }
2595
2596         LOGD("ret : 0x%x", ret);
2597
2598         return ret;
2599 }
2600
2601
2602 int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_status_cb callback, void *user_data)
2603 {
2604         int ret = RECORDER_ERROR_NONE;
2605         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2606         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_STATUS_CB;
2607
2608         if (!pc || !pc->cb_info || callback == NULL) {
2609                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2610                 return RECORDER_ERROR_INVALID_PARAMETER;
2611         }
2612
2613         LOGD("Enter, handle :%x", pc->remote_handle);
2614
2615         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2616
2617         if (ret == RECORDER_ERROR_NONE) {
2618                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS]);
2619
2620                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
2621                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
2622
2623                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS]);
2624         }
2625
2626         LOGD("ret : 0x%x", ret);
2627
2628         return ret;
2629 }
2630
2631
2632 int recorder_unset_recording_status_cb(recorder_h recorder)
2633 {
2634         int ret = RECORDER_ERROR_NONE;
2635         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_STATUS_CB;
2636         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2637
2638         if (!pc || !pc->cb_info) {
2639                 LOGE("NULL handle");
2640                 return RECORDER_ERROR_INVALID_PARAMETER;
2641         }
2642
2643         LOGD("ENTER");
2644
2645         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2646
2647         if (ret == RECORDER_ERROR_NONE) {
2648                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS]);
2649
2650                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
2651                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
2652
2653                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_RECORDING_STATUS]);
2654         }
2655
2656         LOGD("ret : 0x%x", ret);
2657
2658         return ret;
2659 }
2660
2661
2662 int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_recording_limit_reached_cb callback, void *user_data)
2663 {
2664         int ret = RECORDER_ERROR_NONE;
2665         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2666         muse_recorder_api_e api = MUSE_RECORDER_API_SET_RECORDING_LIMIT_REACHED_CB;
2667
2668         if (!pc || !pc->cb_info || callback == NULL) {
2669                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2670                 return RECORDER_ERROR_INVALID_PARAMETER;
2671         }
2672
2673         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2674
2675         if (ret == RECORDER_ERROR_NONE) {
2676                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
2677
2678                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
2679                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
2680
2681                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
2682         }
2683
2684         LOGD("ret : 0x%x", ret);
2685
2686         return ret;
2687 }
2688
2689
2690 int recorder_unset_recording_limit_reached_cb(recorder_h recorder)
2691 {
2692         int ret = RECORDER_ERROR_NONE;
2693         muse_recorder_api_e api = MUSE_RECORDER_API_UNSET_RECORDING_LIMIT_REACHED_CB;
2694         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2695
2696         if (!pc || !pc->cb_info) {
2697                 LOGE("NULL handle");
2698                 return RECORDER_ERROR_INVALID_PARAMETER;
2699         }
2700
2701         LOGD("ENTER");
2702
2703         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2704
2705         if (ret == RECORDER_ERROR_NONE) {
2706                 g_mutex_lock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
2707
2708                 pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
2709                 pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
2710
2711                 g_mutex_unlock(&pc->cb_info->user_cb_mutex[MUSE_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
2712         }
2713
2714         LOGD("ret : 0x%x", ret);
2715
2716         return ret;
2717 }
2718
2719
2720 int recorder_foreach_supported_file_format(recorder_h recorder, recorder_supported_file_format_cb foreach_cb, void *user_data)
2721 {
2722         int ret = RECORDER_ERROR_NONE;
2723         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2724         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_FILE_FORMAT;
2725
2726         if (!pc || !pc->cb_info || foreach_cb == NULL) {
2727                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
2728                 return RECORDER_ERROR_INVALID_PARAMETER;
2729         }
2730
2731         LOGD("Enter, handle :%x", pc->remote_handle);
2732
2733         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = foreach_cb;
2734         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_FILE_FORMAT] = user_data;
2735
2736         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2737
2738         LOGD("ret : 0x%x", ret);
2739
2740         return ret;
2741 }
2742
2743
2744 int recorder_attr_set_size_limit(recorder_h recorder, int kbyte)
2745 {
2746         int ret = RECORDER_ERROR_NONE;
2747         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_SIZE_LIMIT;
2748         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2749         recorder_msg_param param;
2750
2751         if (!pc || !pc->cb_info) {
2752                 LOGE("NULL handle");
2753                 return RECORDER_ERROR_INVALID_PARAMETER;
2754         }
2755
2756         LOGD("ENTER");
2757
2758         RECORDER_MSG_PARAM_SET(param, INT, kbyte);
2759
2760         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2761
2762         LOGD("ret : 0x%x", ret);
2763
2764         return ret;
2765 }
2766
2767
2768 int recorder_attr_set_time_limit(recorder_h recorder, int second)
2769 {
2770         int ret = RECORDER_ERROR_NONE;
2771         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_TIME_LIMIT;
2772         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2773         recorder_msg_param param;
2774
2775         if (!pc || !pc->cb_info) {
2776                 LOGE("NULL handle");
2777                 return RECORDER_ERROR_INVALID_PARAMETER;
2778         }
2779
2780         LOGD("ENTER");
2781
2782         RECORDER_MSG_PARAM_SET(param, INT, second);
2783
2784         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2785
2786         LOGD("ret : 0x%x", ret);
2787
2788         return ret;
2789 }
2790
2791
2792 int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e device)
2793 {
2794         int ret = RECORDER_ERROR_NONE;
2795         int set_device = (int)device;
2796         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_DEVICE;
2797         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2798         recorder_msg_param param;
2799
2800         if (!pc || !pc->cb_info) {
2801                 LOGE("NULL handle");
2802                 return RECORDER_ERROR_INVALID_PARAMETER;
2803         };
2804
2805         LOGD("ENTER");
2806
2807         RECORDER_MSG_PARAM_SET(param, INT, set_device);
2808
2809         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2810
2811         LOGD("ret : 0x%x", ret);
2812
2813         return ret;
2814 }
2815
2816
2817 int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec)
2818 {
2819         int ret = RECORDER_ERROR_NONE;
2820         int set_codec = (int)codec;
2821         muse_recorder_api_e api = MUSE_RECORDER_API_SET_AUDIO_ENCODER;
2822         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2823         recorder_msg_param param;
2824
2825         if (!pc || !pc->cb_info) {
2826                 LOGE("NULL handle");
2827                 return RECORDER_ERROR_INVALID_PARAMETER;
2828         }
2829
2830         LOGD("ENTER");
2831
2832         RECORDER_MSG_PARAM_SET(param, INT, set_codec);
2833
2834         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2835
2836         LOGD("ret : 0x%x", ret);
2837
2838         return ret;
2839 }
2840
2841
2842 int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *codec)
2843 {
2844         int ret = RECORDER_ERROR_NONE;
2845         muse_recorder_api_e api = MUSE_RECORDER_API_GET_AUDIO_ENCODER;
2846         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2847
2848         if (!pc || !pc->cb_info) {
2849                 LOGE("NULL handle");
2850                 return RECORDER_ERROR_INVALID_PARAMETER;
2851         }
2852
2853         if (codec == NULL) {
2854                 LOGE("codec is NULL");
2855                 return RECORDER_ERROR_INVALID_PARAMETER;
2856         }
2857
2858         LOGD("ENTER");
2859
2860         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2861
2862         if (ret == RECORDER_ERROR_NONE)
2863                 *codec = (recorder_audio_codec_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER];
2864
2865         LOGD("ret : 0x%x, codec %d", ret, *codec);
2866
2867         return ret;
2868 }
2869
2870
2871 int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec)
2872 {
2873         int ret = RECORDER_ERROR_NONE;
2874         int set_codec = (int)codec;
2875         muse_recorder_api_e api = MUSE_RECORDER_API_SET_VIDEO_ENCODER;
2876         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2877         recorder_msg_param param;
2878
2879         if (!pc || !pc->cb_info) {
2880                 LOGE("NULL handle");
2881                 return RECORDER_ERROR_INVALID_PARAMETER;
2882         }
2883
2884         LOGD("ENTER");
2885
2886         RECORDER_MSG_PARAM_SET(param, INT, set_codec);
2887
2888         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2889
2890         LOGD("ret : 0x%x", ret);
2891
2892         return ret;
2893 }
2894
2895
2896 int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *codec)
2897 {
2898         int ret = RECORDER_ERROR_NONE;
2899         muse_recorder_api_e api = MUSE_RECORDER_API_GET_VIDEO_ENCODER;
2900         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2901
2902         if (!pc || !pc->cb_info) {
2903                 LOGE("NULL handle");
2904                 return RECORDER_ERROR_INVALID_PARAMETER;
2905         }
2906
2907         if (codec == NULL) {
2908                 LOGE("codec is NULL");
2909                 return RECORDER_ERROR_INVALID_PARAMETER;
2910         }
2911
2912         LOGD("ENTER");
2913
2914         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
2915
2916         if (ret == RECORDER_ERROR_NONE)
2917                 *codec = (recorder_video_codec_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER];
2918
2919         LOGD("ret : 0x%x, codec %d", ret, *codec);
2920
2921         return ret;
2922 }
2923
2924
2925 int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
2926 {
2927         int ret = RECORDER_ERROR_NONE;
2928         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_SAMPLERATE;
2929         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2930         recorder_msg_param param;
2931
2932         if (!pc || !pc->cb_info) {
2933                 LOGE("NULL handle");
2934                 return RECORDER_ERROR_INVALID_PARAMETER;
2935         }
2936
2937         LOGD("ENTER, samplerate : %d", samplerate);
2938
2939         RECORDER_MSG_PARAM_SET(param, INT, samplerate);
2940
2941         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2942
2943         LOGD("ret : 0x%x", ret);
2944
2945         return ret;
2946 }
2947
2948
2949 int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
2950 {
2951         int ret = RECORDER_ERROR_NONE;
2952         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_ENCODER_BITRATE;
2953         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2954         recorder_msg_param param;
2955
2956         if (!pc || !pc->cb_info) {
2957                 LOGE("NULL handle");
2958                 return RECORDER_ERROR_INVALID_PARAMETER;
2959         }
2960
2961         LOGD("ENTER");
2962
2963         RECORDER_MSG_PARAM_SET(param, INT, bitrate);
2964
2965         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2966
2967         LOGD("ret : 0x%x", ret);
2968
2969         return ret;
2970 }
2971
2972
2973 int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate)
2974 {
2975         int ret = RECORDER_ERROR_NONE;
2976         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_VIDEO_ENCODER_BITRATE;
2977         recorder_cli_s *pc = (recorder_cli_s *)recorder;
2978         recorder_msg_param param;
2979
2980         if (!pc || !pc->cb_info) {
2981                 LOGE("NULL handle");
2982                 return RECORDER_ERROR_INVALID_PARAMETER;
2983         }
2984
2985         LOGD("ENTER");
2986
2987         RECORDER_MSG_PARAM_SET(param, INT, bitrate);
2988
2989         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
2990
2991         LOGD("ret : 0x%x", ret);
2992
2993         return ret;
2994 }
2995
2996
2997 int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte)
2998 {
2999         int ret = RECORDER_ERROR_NONE;
3000         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_SIZE_LIMIT;
3001         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3002
3003         if (!pc || !pc->cb_info) {
3004                 LOGE("NULL handle");
3005                 return RECORDER_ERROR_INVALID_PARAMETER;
3006         }
3007
3008         if (kbyte == NULL) {
3009                 LOGE("NULL pointer kbyte");
3010                 return RECORDER_ERROR_INVALID_PARAMETER;
3011         }
3012
3013         LOGD("ENTER");
3014
3015         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3016
3017         if (ret == RECORDER_ERROR_NONE)
3018                 *kbyte = pc->cb_info->get_int_value[_RECORDER_GET_INT_SIZE_LIMIT];
3019
3020         LOGD("ret : 0x%x, %d kbyte", ret, *kbyte);
3021
3022         return ret;
3023 }
3024
3025
3026 int recorder_attr_get_time_limit(recorder_h recorder, int *second)
3027 {
3028         int ret = RECORDER_ERROR_NONE;
3029         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_TIME_LIMIT;
3030         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3031
3032         if (!pc || !pc->cb_info) {
3033                 LOGE("NULL handle");
3034                 return RECORDER_ERROR_INVALID_PARAMETER;
3035         }
3036
3037         if (second == NULL) {
3038                 LOGE("NULL pointer second");
3039                 return RECORDER_ERROR_INVALID_PARAMETER;
3040         }
3041
3042         LOGD("ENTER");
3043
3044         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3045
3046         if (ret == RECORDER_ERROR_NONE)
3047                 *second = pc->cb_info->get_int_value[_RECORDER_GET_INT_TIME_LIMIT];
3048
3049         LOGD("ret : 0x%x, %d second", ret, *second);
3050
3051         return ret;
3052 }
3053
3054
3055 int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e *device)
3056 {
3057         int ret = RECORDER_ERROR_NONE;
3058         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_DEVICE;
3059         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3060
3061         if (!pc || !pc->cb_info) {
3062                 LOGE("NULL handle");
3063                 return RECORDER_ERROR_INVALID_PARAMETER;
3064         }
3065
3066         if (device == NULL) {
3067                 LOGE("NULL pointer device");
3068                 return RECORDER_ERROR_INVALID_PARAMETER;
3069         }
3070
3071         LOGD("ENTER");
3072
3073         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3074
3075         if (ret == RECORDER_ERROR_NONE)
3076                 *device = (recorder_audio_device_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_DEVICE];
3077
3078         LOGD("ret : 0x%x, device %d", ret, *device);
3079
3080         return ret;
3081 }
3082
3083
3084 int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate)
3085 {
3086         int ret = RECORDER_ERROR_NONE;
3087         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_SAMPLERATE;
3088         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3089
3090         if (!pc || !pc->cb_info) {
3091                 LOGE("NULL handle");
3092                 return RECORDER_ERROR_INVALID_PARAMETER;
3093         }
3094
3095         if (samplerate == NULL) {
3096                 LOGE("NULL pointer handle");
3097                 return RECORDER_ERROR_INVALID_PARAMETER;
3098         }
3099
3100         LOGD("ENTER");
3101
3102         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3103
3104         if (ret == RECORDER_ERROR_NONE)
3105                 *samplerate = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_SAMPLERATE];
3106
3107         LOGD("ret : 0x%x, samplerate %d", ret, *samplerate);
3108
3109         return ret;
3110 }
3111
3112
3113 int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate)
3114 {
3115         int ret = RECORDER_ERROR_NONE;
3116         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_ENCODER_BITRATE;
3117         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3118
3119         if (!pc || !pc->cb_info) {
3120                 LOGE("NULL handle");
3121                 return RECORDER_ERROR_INVALID_PARAMETER;
3122         }
3123
3124         if (bitrate == NULL) {
3125                 LOGE("NULL pointer");
3126                 return RECORDER_ERROR_INVALID_PARAMETER;
3127         }
3128
3129         LOGD("ENTER");
3130
3131         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3132
3133         if (ret == RECORDER_ERROR_NONE)
3134                 *bitrate = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_ENCODER_BITRATE];
3135
3136         LOGD("ret : 0x%x, bitrate %d", ret, *bitrate);
3137
3138         return ret;
3139 }
3140
3141
3142 int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate)
3143 {
3144         int ret = RECORDER_ERROR_NONE;
3145         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_VIDEO_ENCODER_BITRATE;
3146         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3147
3148         if (!pc || !pc->cb_info) {
3149                 LOGE("NULL handle");
3150                 return RECORDER_ERROR_INVALID_PARAMETER;
3151         }
3152
3153         if (bitrate == NULL) {
3154                 LOGE("NULL pointer");
3155                 return RECORDER_ERROR_INVALID_PARAMETER;
3156         }
3157
3158         LOGD("ENTER");
3159
3160         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3161
3162         if (ret == RECORDER_ERROR_NONE)
3163                 *bitrate = pc->cb_info->get_int_value[_RECORDER_GET_INT_VIDEO_ENCODER_BITRATE];
3164
3165         LOGD("ret : 0x%x", ret);
3166
3167         return ret;
3168 }
3169
3170
3171 int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_supported_audio_encoder_cb foreach_cb, void *user_data)
3172 {
3173         int ret = RECORDER_ERROR_NONE;
3174         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3175         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_AUDIO_ENCODER;
3176
3177         if (!pc || !pc->cb_info || foreach_cb == NULL) {
3178                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
3179                 return RECORDER_ERROR_INVALID_PARAMETER;
3180         }
3181
3182         LOGD("Enter, handle :%x", pc->remote_handle);
3183
3184         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = foreach_cb;
3185         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_AUDIO_ENCODER] = user_data;
3186
3187         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3188
3189         LOGD("ret : 0x%x", ret);
3190
3191         return ret;
3192 }
3193
3194
3195 int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_supported_video_encoder_cb foreach_cb, void *user_data)
3196 {
3197         int ret = RECORDER_ERROR_NONE;
3198         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3199         muse_recorder_api_e api = MUSE_RECORDER_API_FOREACH_SUPPORTED_VIDEO_ENCODER;
3200
3201         if (!pc || !pc->cb_info || foreach_cb == NULL) {
3202                 LOGE("INVALID_PARAMETER(0x%08x)", RECORDER_ERROR_INVALID_PARAMETER);
3203                 return RECORDER_ERROR_INVALID_PARAMETER;
3204         }
3205
3206         LOGD("Enter, handle :%x", pc->remote_handle);
3207
3208         pc->cb_info->user_cb[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = foreach_cb;
3209         pc->cb_info->user_data[MUSE_RECORDER_EVENT_TYPE_FOREACH_SUPPORTED_VIDEO_ENCODER] = user_data;
3210
3211         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3212
3213         LOGD("ret : 0x%x", ret);
3214
3215         return ret;
3216 }
3217
3218
3219 int recorder_attr_set_mute(recorder_h recorder, bool enable)
3220 {
3221         int ret = RECORDER_ERROR_NONE;
3222         int set_enable = (int)enable;
3223         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_MUTE;
3224         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3225         recorder_msg_param param;
3226
3227         if (!pc || !pc->cb_info) {
3228                 LOGE("NULL handle");
3229                 return RECORDER_ERROR_INVALID_PARAMETER;
3230         }
3231
3232         LOGD("ENTER");
3233
3234         RECORDER_MSG_PARAM_SET(param, INT, set_enable);
3235
3236         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
3237
3238         LOGD("ret : 0x%x", ret);
3239
3240         return ret;
3241 }
3242
3243
3244 bool recorder_attr_is_muted(recorder_h recorder)
3245 {
3246         int ret = false;
3247         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_IS_MUTED;
3248         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3249
3250         if (!pc || !pc->cb_info) {
3251                 LOGE("NULL handle");
3252                 return false;
3253         }
3254
3255         LOGD("ENTER");
3256
3257         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3258
3259         if (ret == RECORDER_ERROR_SERVICE_DISCONNECTED)
3260                 ret = false;
3261
3262         LOGD("ret : %d", ret);
3263
3264         return (bool)ret;
3265 }
3266
3267
3268 int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
3269 {
3270         int ret = RECORDER_ERROR_NONE;
3271         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_RECORDING_MOTION_RATE;
3272         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3273         recorder_msg_param param;
3274
3275         if (!pc || !pc->cb_info) {
3276                 LOGE("NULL handle");
3277                 return RECORDER_ERROR_INVALID_PARAMETER;
3278         }
3279
3280         LOGD("ENTER - %.20lf", rate);
3281
3282         RECORDER_MSG_PARAM_SET(param, DOUBLE, rate);
3283
3284         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
3285
3286         LOGD("ret : 0x%x", ret);
3287
3288         return ret;
3289 }
3290
3291
3292 int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
3293 {
3294         int ret = RECORDER_ERROR_NONE;
3295         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_RECORDING_MOTION_RATE;
3296         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3297
3298         if (!pc || !pc->cb_info) {
3299                 LOGE("NULL handle");
3300                 return RECORDER_ERROR_INVALID_PARAMETER;
3301         }
3302
3303         if (rate == NULL) {
3304                 LOGE("rate is NULL");
3305                 return RECORDER_ERROR_INVALID_PARAMETER;
3306         }
3307
3308         LOGD("ENTER");
3309
3310         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3311         if (ret == RECORDER_ERROR_NONE)
3312                 *rate = pc->cb_info->get_double_value[_RECORDER_GET_DOUBLE_RECORDING_MOTION_RATE];
3313
3314         LOGD("ret : 0x%x - rate %.20lf", ret, *rate);
3315
3316         return ret;
3317 }
3318
3319
3320 int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
3321 {
3322         int ret = RECORDER_ERROR_NONE;
3323         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_AUDIO_CHANNEL;
3324         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3325         recorder_msg_param param;
3326
3327         if (!pc || !pc->cb_info) {
3328                 LOGE("NULL handle");
3329                 return RECORDER_ERROR_INVALID_PARAMETER;
3330         }
3331
3332         LOGD("ENTER");
3333
3334         RECORDER_MSG_PARAM_SET(param, INT, channel_count);
3335
3336         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
3337
3338         LOGD("ret : 0x%x", ret);
3339
3340         return ret;
3341 }
3342
3343
3344 int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count)
3345 {
3346         int ret = RECORDER_ERROR_NONE;
3347         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_AUDIO_CHANNEL;
3348         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3349
3350         if (!pc || !pc->cb_info) {
3351                 LOGE("NULL handle");
3352                 return RECORDER_ERROR_INVALID_PARAMETER;
3353         }
3354
3355         if (channel_count == NULL) {
3356                 LOGE("channel_count is NULL");
3357                 return RECORDER_ERROR_INVALID_PARAMETER;
3358         }
3359
3360         LOGD("ENTER");
3361
3362         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3363
3364         if (ret == RECORDER_ERROR_NONE)
3365                 *channel_count = pc->cb_info->get_int_value[_RECORDER_GET_INT_AUDIO_CHANNEL];
3366
3367         LOGD("ret : 0x%x, channel count %d", ret, *channel_count);
3368
3369         return ret;
3370 }
3371
3372
3373 int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e orientation)
3374 {
3375         int ret = RECORDER_ERROR_NONE;
3376         int set_orientation = (int)orientation;
3377         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_SET_ORIENTATION_TAG;
3378         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3379         recorder_msg_param param;
3380
3381         if (!pc || !pc->cb_info) {
3382                 LOGE("NULL handle");
3383                 return RECORDER_ERROR_INVALID_PARAMETER;
3384         }
3385
3386         LOGD("ENTER");
3387
3388         RECORDER_MSG_PARAM_SET(param, INT, set_orientation);
3389
3390         _recorder_msg_send_param1(api, pc->cb_info, &ret, &param);
3391
3392         LOGD("ret : 0x%x", ret);
3393
3394         return ret;
3395 }
3396
3397
3398 int  recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e *orientation)
3399 {
3400         int ret = RECORDER_ERROR_NONE;
3401         muse_recorder_api_e api = MUSE_RECORDER_API_ATTR_GET_ORIENTATION_TAG;
3402         recorder_cli_s *pc = (recorder_cli_s *)recorder;
3403
3404         if (!pc || !pc->cb_info) {
3405                 LOGE("NULL handle");
3406                 return RECORDER_ERROR_INVALID_PARAMETER;
3407         }
3408
3409         if (orientation == NULL) {
3410                 LOGE("orientation is NULL");
3411                 return RECORDER_ERROR_INVALID_PARAMETER;
3412         }
3413
3414         LOGD("ENTER");
3415
3416         _recorder_msg_send(api, pc->cb_info, &ret, RECORDER_CB_TIMEOUT);
3417
3418         if (ret == RECORDER_ERROR_NONE)
3419                 *orientation = (recorder_rotation_e)pc->cb_info->get_int_value[_RECORDER_GET_INT_ORIENTATION_TAG];
3420
3421         LOGD("ret : 0x%x, orientation %d", ret, *orientation);
3422
3423         return ret;
3424 }
3425
3426
3427 int recorder_get_device_state(recorder_type_e type, recorder_device_state_e *state)
3428 {
3429         int ret = RECORDER_ERROR_NONE;
3430         int sock_fd = -1;
3431         int get_device_state = 0;
3432         char *send_msg = NULL;
3433         char recv_msg[MUSE_RECORDER_MSG_MAX_LENGTH] = {'\0',};
3434
3435         if (!state) {
3436                 LOGE("NULL pointer");
3437                 return RECORDER_ERROR_INVALID_PARAMETER;
3438         }
3439
3440         LOGD("Enter - type %d", type);
3441
3442         sock_fd = muse_client_new();
3443         if (sock_fd < 0) {
3444                 LOGE("muse_client_new failed - returned fd %d", sock_fd);
3445                 ret = RECORDER_ERROR_INVALID_OPERATION;
3446                 goto _GET_DEVICE_STATE_EXIT;
3447         }
3448
3449         send_msg = muse_core_msg_new(MUSE_RECORDER_API_GET_DEVICE_STATE,
3450                 MUSE_TYPE_INT, "module", MUSE_RECORDER,
3451                 MUSE_TYPE_INT, PARAM_RECORDER_TYPE, type,
3452                 NULL);
3453         if (!send_msg) {
3454                 LOGE("NULL msg");
3455                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
3456                 goto _GET_DEVICE_STATE_EXIT;
3457         }
3458
3459         LOGD("sock_fd : %d, msg : %s", sock_fd, send_msg);
3460
3461         ret = muse_core_msg_send(sock_fd, send_msg);
3462
3463         muse_core_msg_free(send_msg);
3464         send_msg = NULL;
3465
3466         if (ret < 0) {
3467                 LOGE("send msg failed %d", errno);
3468                 ret = RECORDER_ERROR_INVALID_OPERATION;
3469                 goto _GET_DEVICE_STATE_EXIT;
3470         }
3471
3472         ret = muse_core_msg_recv(sock_fd, recv_msg, MUSE_RECORDER_MSG_MAX_LENGTH);
3473         if (ret <= 0) {
3474                 LOGE("recv msg failed %d", errno);
3475                 ret = RECORDER_ERROR_INVALID_OPERATION;
3476                 goto _GET_DEVICE_STATE_EXIT;
3477         }
3478
3479         if (!muse_recorder_msg_get(ret, recv_msg)) {
3480                 LOGE("failed to get return value from msg [%s]", recv_msg);
3481                 ret = RECORDER_ERROR_INVALID_OPERATION;
3482                 goto _GET_DEVICE_STATE_EXIT;
3483         }
3484
3485         if (ret == RECORDER_ERROR_NONE) {
3486                 if (muse_recorder_msg_get(get_device_state, recv_msg)) {
3487                         *state = (recorder_device_state_e)get_device_state;
3488                         LOGD("device type %d state %d", type, *state);
3489                 } else {
3490                         LOGE("failed to get device state from msg [%s]", recv_msg);
3491                         ret = RECORDER_ERROR_INVALID_OPERATION;
3492                 }
3493         } else {
3494                 LOGE("failed 0x%x", ret);
3495         }
3496
3497 _GET_DEVICE_STATE_EXIT:
3498         if (sock_fd > -1) {
3499                 muse_client_close(sock_fd);
3500                 sock_fd = -1;
3501         }
3502
3503         return ret;
3504 }
3505
3506
3507 int recorder_add_device_state_changed_cb(recorder_device_state_changed_cb callback, void *user_data, int *cb_id)
3508 {
3509         int ret = RECORDER_ERROR_NONE;
3510         recorder_device_state_e state = RECORDER_DEVICE_STATE_IDLE;
3511         recorder_cb_info *info = NULL;
3512
3513         if (!callback || !cb_id) {
3514                 LOGE("invalid pointer %p %p", callback, cb_id);
3515                 return RECORDER_ERROR_INVALID_PARAMETER;
3516         }
3517
3518         g_mutex_lock(&g_rec_dev_state_changed_cb_lock);
3519
3520         /* check recorder support */
3521         ret = recorder_get_device_state(RECORDER_TYPE_AUDIO, &state);
3522         if (ret != RECORDER_ERROR_NONE) {
3523                 LOGE("get device state failed");
3524                 g_mutex_unlock(&g_rec_dev_state_changed_cb_lock);
3525                 return ret;
3526         }
3527
3528         info = g_new0(recorder_cb_info, 1);
3529         if (!info) {
3530                 LOGE("info failed");
3531                 ret = RECORDER_ERROR_OUT_OF_MEMORY;
3532                 goto _DONE;
3533         }
3534
3535         info->id = ++g_rec_dev_state_changed_cb_id;
3536         info->callback = (void *)callback;
3537         info->user_data = user_data;
3538
3539         *cb_id = info->id;
3540
3541         /* subscribe dbus signal for camera state change */
3542         if (!g_rec_dev_state_changed_cb_conn) {
3543                 g_rec_dev_state_changed_cb_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
3544                 if (!g_rec_dev_state_changed_cb_conn) {
3545                         LOGE("failed to get gdbus connection");
3546                         ret = RECORDER_ERROR_INVALID_OPERATION;
3547                         goto _DONE;
3548                 }
3549
3550                 LOGD("subscribe signal %s - %s - %s",
3551                         MM_CAMCORDER_DBUS_OBJECT,
3552                         MM_CAMCORDER_DBUS_INTERFACE_RECORDER,
3553                         MM_CAMCORDER_DBUS_SIGNAL_STATE_CHANGED);
3554
3555                 g_rec_dev_state_changed_cb_subscribe_id = g_dbus_connection_signal_subscribe(g_rec_dev_state_changed_cb_conn,
3556                         NULL, MM_CAMCORDER_DBUS_INTERFACE_RECORDER, MM_CAMCORDER_DBUS_SIGNAL_STATE_CHANGED, MM_CAMCORDER_DBUS_OBJECT, NULL,
3557                         G_DBUS_SIGNAL_FLAGS_NONE, (GDBusSignalCallback)__recorder_device_state_changed_cb, NULL, NULL);
3558                 if (!g_rec_dev_state_changed_cb_subscribe_id) {
3559                         LOGE("failed to get gdbus connection");
3560                         ret = RECORDER_ERROR_INVALID_OPERATION;
3561                         goto _DONE;
3562                 }
3563
3564                 LOGD("signal subscribe id %u", g_rec_dev_state_changed_cb_subscribe_id);
3565         }
3566
3567         g_rec_dev_state_changed_cb_list = g_list_prepend(g_rec_dev_state_changed_cb_list, (gpointer)info);
3568
3569         LOGD("callback id %d", info->id);
3570
3571 _DONE:
3572         if (ret != RECORDER_ERROR_NONE) {
3573                 if (info) {
3574                         g_free(info);
3575                         info = NULL;
3576                 }
3577
3578                 if (g_rec_dev_state_changed_cb_conn) {
3579                         g_object_unref(g_rec_dev_state_changed_cb_conn);
3580                         g_rec_dev_state_changed_cb_conn = NULL;
3581                 }
3582         }
3583
3584         g_mutex_unlock(&g_rec_dev_state_changed_cb_lock);
3585
3586         return ret;
3587 }
3588
3589
3590 int recorder_remove_device_state_changed_cb(int cb_id)
3591 {
3592         int ret = RECORDER_ERROR_NONE;
3593         recorder_device_state_e state = RECORDER_DEVICE_STATE_IDLE;
3594         GList *tmp_list = NULL;
3595         recorder_cb_info *info = NULL;
3596
3597         /* check recorder support */
3598         ret = recorder_get_device_state(RECORDER_TYPE_AUDIO, &state);
3599         if (ret != RECORDER_ERROR_NONE) {
3600                 LOGE("get device state failed");
3601                 return ret;
3602         }
3603
3604         g_mutex_lock(&g_rec_dev_state_changed_cb_lock);
3605
3606         if (!g_rec_dev_state_changed_cb_list) {
3607                 LOGE("there is no callback info");
3608                 ret = RECORDER_ERROR_INVALID_OPERATION;
3609                 goto _DONE;
3610         }
3611
3612         tmp_list = g_rec_dev_state_changed_cb_list;
3613
3614         do {
3615                 info = tmp_list->data;
3616                 tmp_list = tmp_list->next;
3617
3618                 if (!info) {
3619                         LOGW("NULL info");
3620                         continue;
3621                 }
3622
3623                 if (info->id == cb_id) {
3624                         g_rec_dev_state_changed_cb_list = g_list_remove(g_rec_dev_state_changed_cb_list, info);
3625
3626                         g_free(info);
3627                         info = NULL;
3628
3629                         if (!g_rec_dev_state_changed_cb_list) {
3630                                 /* no remained callback */
3631                                 if (g_rec_dev_state_changed_cb_conn) {
3632                                         /* unsubscribe signal */
3633                                         g_dbus_connection_signal_unsubscribe(g_rec_dev_state_changed_cb_conn, g_rec_dev_state_changed_cb_subscribe_id);
3634                                         g_rec_dev_state_changed_cb_subscribe_id = 0;
3635
3636                                         /* unref connection */
3637                                         g_object_unref(g_rec_dev_state_changed_cb_conn);
3638                                         g_rec_dev_state_changed_cb_conn = NULL;
3639                                 }
3640                         }
3641
3642                         LOGD("id %d callback removed", cb_id);
3643                         ret = RECORDER_ERROR_NONE;
3644
3645                         goto _DONE;
3646                 }
3647         } while (tmp_list);
3648
3649         LOGE("id %d callback not found", cb_id);
3650         ret = RECORDER_ERROR_INVALID_PARAMETER;
3651
3652 _DONE:
3653         g_mutex_unlock(&g_rec_dev_state_changed_cb_lock);
3654
3655         return ret;
3656 }