X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmm_radio_priv_hal.c;h=3d1f8d6f8bad4e39de4cf47e83c05ffbc005bfa4;hb=cc9cd23fde25c4756919d55eb62d4761fd51efcc;hp=5dab31bd28729b1ef7cdad6da70a5172d3b99787;hpb=74e23588fee3723faf3ebed27a81fa2959ac222f;p=platform%2Fcore%2Fmultimedia%2Flibmm-radio.git diff --git a/src/mm_radio_priv_hal.c b/src/mm_radio_priv_hal.c index 5dab31b..3d1f8d6 100644 --- a/src/mm_radio_priv_hal.c +++ b/src/mm_radio_priv_hal.c @@ -123,8 +123,10 @@ void _mmradio_seek_cancel(mm_radio_t *radio); static void __mmradio_seek_thread(mm_radio_t *radio); static void __mmradio_scan_thread(mm_radio_t *radio); static bool __is_tunable_frequency(mm_radio_t *radio, int freq); -static int __mmradio_create_thread(mm_radio_t *radio); -static void __mmradio_destroy_thread(mm_radio_t *radio); +static int __mmradio_create_threads(mm_radio_t *radio); +static void __mmradio_destroy_threads(mm_radio_t *radio); +static int __mmradio_create_thread_type(mm_radio_t *radio, MMRadioThreadTypes type); +static void __mmradio_destroy_thread_type(mm_radio_t *radio, MMRadioThreadTypes type); static void __mmradio_volume_changed_cb(volume_type_t type, unsigned int volume, void *user_data); static int __mmradio_set_media_volume(mm_radio_t *radio, unsigned int level); @@ -133,6 +135,13 @@ static int __resource_release_cb(mm_resource_manager_h rm, static void __mmradio_msg_thread(mm_radio_t *radio); static void __mmradio_msg_push(mm_radio_t *radio, MMRadioMsgTypes msg_type, int msg_data); +typedef void (*thread_function)(mm_radio_t *); +thread_function __mmradio_thread_function[] = { + &__mmradio_msg_thread, + &__mmradio_seek_thread, + &__mmradio_scan_thread +}; + int _mmradio_apply_region(mm_radio_t *radio, MMRadioRegionType region, bool update) { int ret = MM_ERROR_NONE; @@ -196,7 +205,7 @@ int _mmradio_create_radio(mm_radio_t *radio) } /* create mutex and thread */ - ret = __mmradio_create_thread(radio); + ret = __mmradio_create_threads(radio); if (ret) { MMRADIO_LOG_ERROR("failed to create threads"); goto ERROR_THREAD; @@ -226,7 +235,7 @@ int _mmradio_create_radio(mm_radio_t *radio) ERROR_HAL_INIT: mm_resource_manager_destroy(radio->resource_manager); ERROR_RESOURCE: - __mmradio_destroy_thread(radio); + __mmradio_destroy_threads(radio); ERROR_THREAD: if (radio->msg_queue) g_async_queue_unref(radio->msg_queue); @@ -342,7 +351,7 @@ int _mmradio_destroy(mm_radio_t *radio) _mmradio_unrealize(radio); /* destroy mutex and thread */ - __mmradio_destroy_thread(radio); + __mmradio_destroy_threads(radio); if (radio->msg_queue) g_async_queue_unref(radio->msg_queue); @@ -673,13 +682,17 @@ int _mmradio_stop(mm_radio_t *radio) int _mmradio_seek(mm_radio_t *radio, MMRadioSeekDirectionType direction) { int ret = MM_ERROR_NONE; + MMRadioThread_t *p_thread = NULL; MMRADIO_LOG_FENTER(); MMRADIO_CHECK_INSTANCE(radio); MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SEEK); - if (radio->seek.is_running) { + p_thread = &radio->thread[MM_RADIO_THREAD_SEEK]; + MMRADIO_CHECK_ARG(p_thread); + + if (p_thread->is_running) { MMRADIO_LOG_ERROR("[RADIO_ERROR_INVALID_OPERATION]radio is seeking, can't serve another request try again"); return MM_ERROR_RADIO_INTERNAL; } @@ -699,10 +712,10 @@ int _mmradio_seek(mm_radio_t *radio, MMRadioSeekDirectionType direction) MMRADIO_LOG_INFO("trying to seek. direction[0:UP/1:DOWN) %d", direction); radio->seek_direction = direction; - radio->seek.is_running = true; - radio->seek.stop = false; + p_thread->is_running = true; + p_thread->stop = false; - MMRADIO_SEEK_THREAD_SIGNAL(radio); + MMRADIO_THREAD_SIGNAL(p_thread); MMRADIO_LOG_FLEAVE(); @@ -716,7 +729,7 @@ void _mmradio_seek_cancel(mm_radio_t *radio) MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio); /* cancel any outstanding seek request */ - radio->seek.stop = true; + radio->thread[MM_RADIO_THREAD_SEEK].stop = true; MMRADIO_LOG_FLEAVE(); } @@ -724,13 +737,17 @@ void _mmradio_seek_cancel(mm_radio_t *radio) int _mmradio_start_scan(mm_radio_t *radio) { int ret = MM_ERROR_NONE; + MMRadioThread_t *p_thread = NULL;; MMRADIO_LOG_FENTER(); MMRADIO_CHECK_INSTANCE(radio); MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_START_SCAN); - radio->scan.stop = false; + p_thread = &radio->thread[MM_RADIO_THREAD_SCAN]; + MMRADIO_CHECK_ARG(p_thread); + + p_thread->stop = false; if (!radio->is_ready) { ret = mm_resource_manager_mark_for_acquire(radio->resource_manager, @@ -772,9 +789,9 @@ int _mmradio_start_scan(mm_radio_t *radio) MMRADIO_LOG_DEBUG("radio prepared and opened"); } - radio->scan.is_running = true; + p_thread->is_running = true; - MMRADIO_SCAN_THREAD_SIGNAL(radio); + MMRADIO_THREAD_SIGNAL(p_thread); MMRADIO_SET_STATE(radio, MM_RADIO_STATE_SCANNING); @@ -790,7 +807,7 @@ int _mmradio_stop_scan(mm_radio_t *radio) MMRADIO_CHECK_INSTANCE(radio); MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_STOP_SCAN); - radio->scan.stop = true; + radio->thread[MM_RADIO_THREAD_SCAN].stop = true; MMRADIO_LOG_FLEAVE(); @@ -826,26 +843,37 @@ void __mmradio_scan_thread(mm_radio_t *radio) int ret = MM_ERROR_NONE; int prev_freq = 0; + MMRadioThread_t *p_thread = NULL; + MMRADIO_LOG_FENTER(); MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio); - MMRADIO_SCAN_THREAD_LOCK(radio); + p_thread = &radio->thread[MM_RADIO_THREAD_SCAN]; + MMRADIO_CHECK_ARG_RETURN_VOID(p_thread); + + MMRADIO_THREAD_LOCK(p_thread); + MMRADIO_THREAD_SIGNAL(p_thread); + MMRADIO_THREAD_UNLOCK(p_thread); - while (!radio->scan.thread_exit) { + MMRADIO_THREAD_LOCK(p_thread); + + while (!p_thread->thread_exit) { MMRADIO_LOG_DEBUG("scan thread started. waiting for signal."); - MMRADIO_SCAN_THREAD_WAIT(radio); + MMRADIO_THREAD_WAIT(p_thread); - if (radio->scan.thread_exit) { + if (p_thread->thread_exit) { MMRADIO_LOG_DEBUG("exiting scan thread"); goto EXIT; } - ret = radio_hal_mute(radio->hal_inf); - if (ret == MM_ERROR_NOT_SUPPORT_API) { - MMRADIO_LOG_WARNING("radio_hal_mute is not supported"); - } else if (ret != MM_ERROR_NONE) { - MMRADIO_LOG_ERROR("faied to set radio hal mute"); - goto FINISHED; + if (radio->old_state == MM_RADIO_STATE_PLAYING) { + ret = radio_hal_mute(radio->hal_inf); + if (ret == MM_ERROR_NOT_SUPPORT_API) { + MMRADIO_LOG_WARNING("radio_hal_mute is not supported"); + } else if (ret != MM_ERROR_NONE) { + MMRADIO_LOG_ERROR("faied to set radio hal mute"); + goto FINISHED; + } } ret = radio_hal_set_frequency(radio->hal_inf, radio->region_setting.band_min); @@ -856,17 +884,17 @@ void __mmradio_scan_thread(mm_radio_t *radio) MMRADIO_SET_STATE(radio, MM_RADIO_STATE_SCANNING); prev_freq = 0; - while (!radio->scan.stop) { + while (!p_thread->stop) { uint32_t freq = 0; MMRADIO_LOG_DEBUG("scanning...."); - if (radio->scan.thread_exit) { + if (p_thread->thread_exit) { MMRADIO_LOG_DEBUG("exiting scan thread"); goto EXIT; } - if (radio->scan.stop) { + if (p_thread->stop) { MMRADIO_LOG_INFO("scan was canceled"); goto FINISHED; } @@ -879,12 +907,12 @@ void __mmradio_scan_thread(mm_radio_t *radio) break; } - if (radio->scan.thread_exit) { + if (p_thread->thread_exit) { MMRADIO_LOG_DEBUG("exiting scan thread"); goto EXIT; } - if (radio->scan.stop) { + if (p_thread->stop) { MMRADIO_LOG_INFO("scan was canceled"); goto FINISHED; } @@ -908,7 +936,7 @@ void __mmradio_scan_thread(mm_radio_t *radio) break; } - if (radio->scan.stop) { + if (p_thread->stop) { /* doesn't need to post */ break; } @@ -973,19 +1001,19 @@ FINISHED_ERR: MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY); } - if (!radio->scan.stop) + if (!p_thread->stop) __mmradio_msg_push(radio, MM_RADIO_MSG_SCAN_FINISHED, 0); else __mmradio_msg_push(radio, MM_RADIO_MSG_SCAN_STOPPED, 0); - radio->scan.is_running = false; + p_thread->is_running = false; } EXIT: - radio->scan.is_running = false; + p_thread->is_running = false; - MMRADIO_SCAN_THREAD_UNLOCK(radio); + MMRADIO_THREAD_UNLOCK(p_thread); MMRADIO_LOG_FLEAVE(); @@ -1012,17 +1040,25 @@ void __mmradio_seek_thread(mm_radio_t *radio) { int ret = MM_ERROR_NONE; uint32_t freq = 0; + MMRadioThread_t *p_thread = NULL; MMRADIO_LOG_FENTER(); MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio); - MMRADIO_SEEK_THREAD_LOCK(radio); + p_thread = &radio->thread[MM_RADIO_THREAD_SEEK]; + MMRADIO_CHECK_ARG_RETURN_VOID(p_thread); + + MMRADIO_THREAD_LOCK(p_thread); + MMRADIO_THREAD_SIGNAL(p_thread); + MMRADIO_THREAD_UNLOCK(p_thread); - while (!radio->seek.thread_exit) { + MMRADIO_THREAD_LOCK(p_thread); + + while (!p_thread->thread_exit) { MMRADIO_LOG_DEBUG("seek thread started. waiting for signal."); - MMRADIO_SEEK_THREAD_WAIT(radio); + MMRADIO_THREAD_WAIT(p_thread); - if (radio->seek.thread_exit) { + if (p_thread->thread_exit) { MMRADIO_LOG_DEBUG("exiting seek thread"); goto EXIT; } @@ -1030,7 +1066,7 @@ void __mmradio_seek_thread(mm_radio_t *radio) MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SEEK_START, NULL); MMRADIO_LOG_DEBUG("seeking...."); - if (radio->seek.stop) { + if (p_thread->stop) { MMRADIO_LOG_INFO("seek was canceled so we return failure to application"); goto SEEK_FAILED; } @@ -1045,12 +1081,12 @@ void __mmradio_seek_thread(mm_radio_t *radio) goto SEEK_FAILED; } - if (radio->seek.thread_exit) { + if (p_thread->thread_exit) { MMRADIO_LOG_DEBUG("exiting seek thread"); goto EXIT; } - if (radio->seek.stop) { + if (p_thread->stop) { MMRADIO_LOG_INFO("seek was canceled so we return failure to application"); goto SEEK_FAILED; } @@ -1098,7 +1134,7 @@ void __mmradio_seek_thread(mm_radio_t *radio) radio->prev_seek_freq = (int)freq; MMRADIO_LOG_INFO("seeking : new frequency : [%d]", (int) freq); __mmradio_msg_push(radio, MM_RADIO_MSG_SEEK_FINISHED, freq); - radio->seek.is_running = false; + p_thread->is_running = false; continue; SEEK_FAILED: @@ -1114,12 +1150,12 @@ SEEK_FAILED: } /* freq -1 means it's failed to seek */ __mmradio_msg_push(radio, MM_RADIO_MSG_SEEK_FINISHED, -1); - radio->seek.is_running = false; + p_thread->is_running = false; } EXIT: - radio->seek.is_running = false; - MMRADIO_SEEK_THREAD_UNLOCK(radio); + p_thread->is_running = false; + MMRADIO_THREAD_UNLOCK(p_thread); MMRADIO_LOG_FLEAVE(); pthread_exit(NULL); } @@ -1488,128 +1524,149 @@ static int __resource_release_cb(mm_resource_manager_h rm, return FALSE; } -static int __mmradio_create_thread(mm_radio_t *radio) +static int __mmradio_create_thread_type(mm_radio_t *radio, MMRadioThreadTypes type) { - int ret = MM_ERROR_NONE; + MMRadioThread_t *p_thread = NULL; MMRADIO_LOG_FENTER(); MMRADIO_CHECK_INSTANCE(radio); - MMRADIO_INIT_MUTEX(radio->cmd_lock); - MMRADIO_INIT_MUTEX(radio->volume_lock); - MMRADIO_INIT_MUTEX(radio->hal_seek_mutex); - - radio->msg.thread_id = pthread_create(&radio->msg.thread, NULL, - (void *)__mmradio_msg_thread, (void *)radio); - if (radio->msg.thread_id) { - /* NOTE : we are dealing it as an error since we cannot expect it's behavior */ - MMRADIO_LOG_ERROR("failed to create thread : msg"); - goto ERROR; + if (type >= MM_RADIO_THREAD_NUM) { + MMRADIO_LOG_WARNING("wrong argument thread type"); + return MM_ERROR_RADIO_INTERNAL; } - MMRADIO_INIT_MUTEX(radio->seek.mutex); - MMRADIO_INIT_COND(radio->seek.cond); - - radio->seek.thread_id = pthread_create(&radio->seek.thread, NULL, - (void *)__mmradio_seek_thread, (void *)radio); - if (radio->seek.thread_id) { - MMRADIO_LOG_DEBUG("failed to create thread : seek"); - goto ERROR; - } + p_thread = &radio->thread[type]; + MMRADIO_CHECK_ARG(p_thread); - MMRADIO_INIT_MUTEX(radio->scan.mutex); - MMRADIO_INIT_COND(radio->scan.cond); + MMRADIO_INIT_MUTEX(p_thread->mutex); + MMRADIO_INIT_COND(p_thread->cond); - radio->scan.thread_id = pthread_create(&radio->scan.thread, NULL, - (void *)__mmradio_scan_thread, (void *)radio); - if (radio->scan.thread_id) { - MMRADIO_LOG_ERROR("failed to create thread : scan"); - goto ERROR; + MMRADIO_THREAD_LOCK(p_thread); + p_thread->thread_id = pthread_create(&p_thread->thread, NULL, + (void *)__mmradio_thread_function[type], (void *)radio); + if (p_thread->thread_id) { + MMRADIO_LOG_DEBUG("failed to create thread : [%d]", type); + MMRADIO_THREAD_UNLOCK(p_thread); + return MM_ERROR_RADIO_INTERNAL; } - MMRADIO_LOG_FLEAVE(); - return ret; + MMRADIO_LOG_DEBUG("wait for [%d] thread", type); + MMRADIO_THREAD_WAIT(p_thread); + MMRADIO_LOG_DEBUG("[%d] thread started", type); + MMRADIO_THREAD_UNLOCK(p_thread); + + return MM_ERROR_NONE; ERROR: - if (radio->seek.thread) { - MMRADIO_SEEK_THREAD_LOCK(radio); - radio->seek.thread_exit = true; - MMRADIO_SEEK_THREAD_SIGNAL(radio); - MMRADIO_SEEK_THREAD_UNLOCK(radio); - pthread_join(radio->seek.thread, NULL); - radio->seek.thread = 0; - } + pthread_mutex_destroy(&p_thread->mutex); + pthread_cond_destroy(&p_thread->cond); + return MM_ERROR_RADIO_INTERNAL; - if (radio->msg.thread) { - mm_radio_msg_t *msg = g_slice_new0(mm_radio_msg_t); - if (!msg) { - MMRADIO_LOG_ERROR("failed to get mm_radio_msg_t"); - } else { - msg->msg_type = MM_RADIO_MSG_DESTROY; - g_async_queue_push_front(radio->msg_queue, msg); - pthread_join(radio->msg.thread, NULL); - radio->msg.thread = 0; +} + +static int __mmradio_create_threads(mm_radio_t *radio) +{ + int ret = MM_ERROR_NONE; + int type = 0; + + MMRADIO_LOG_FENTER(); + + MMRADIO_CHECK_INSTANCE(radio); + + MMRADIO_INIT_MUTEX(radio->cmd_lock); + MMRADIO_INIT_MUTEX(radio->volume_lock); + MMRADIO_INIT_MUTEX(radio->hal_seek_mutex); + + for (type = (int)MM_RADIO_THREAD_MSG; type < (int)MM_RADIO_THREAD_NUM; type++) { + ret = __mmradio_create_thread_type(radio, (MMRadioThreadTypes)type); + if (ret) { + MMRADIO_LOG_ERROR("failed to create thread(%d)", type); + while (--type >= (int)MM_RADIO_THREAD_MSG) + __mmradio_destroy_thread_type(radio, (MMRadioThreadTypes)type); + goto ERROR; } } + MMRADIO_LOG_FLEAVE(); + return ret; + +ERROR: pthread_mutex_destroy(&radio->cmd_lock); pthread_mutex_destroy(&radio->volume_lock); pthread_mutex_destroy(&radio->hal_seek_mutex); - pthread_mutex_destroy(&radio->seek.mutex); - pthread_cond_destroy(&radio->seek.cond); - pthread_mutex_destroy(&radio->scan.mutex); - pthread_cond_destroy(&radio->scan.cond); + MMRADIO_LOG_FLEAVE(); return MM_ERROR_RADIO_INTERNAL; } -static void __mmradio_destroy_thread(mm_radio_t *radio) +static void __mmradio_destroy_thread_type(mm_radio_t *radio, MMRadioThreadTypes type) { + MMRadioThread_t *p_thread = NULL; + mm_radio_msg_t *msg = NULL; MMRADIO_LOG_FENTER(); MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio); - if (radio->seek.thread) { - MMRADIO_SEEK_THREAD_LOCK(radio); - radio->seek.thread_exit = true; - MMRADIO_SEEK_THREAD_SIGNAL(radio); - MMRADIO_SEEK_THREAD_UNLOCK(radio); - pthread_join(radio->seek.thread, NULL); - radio->seek.thread = 0; + if (type >= MM_RADIO_THREAD_NUM) { + MMRADIO_LOG_WARNING("wrong argument thread type"); + return; } - if (radio->scan.thread) { - MMRADIO_SCAN_THREAD_LOCK(radio); - radio->scan.thread_exit = true; - MMRADIO_SCAN_THREAD_SIGNAL(radio); - MMRADIO_SCAN_THREAD_UNLOCK(radio); - pthread_join(radio->scan.thread, NULL); - radio->scan.thread = 0; - } + p_thread = &radio->thread[type]; + MMRADIO_CHECK_ARG_RETURN_VOID(p_thread); - if (radio->msg.thread) { - mm_radio_msg_t *msg = g_slice_new0(mm_radio_msg_t); - if (!msg) { - MMRADIO_LOG_ERROR("failed to get mm_radio_msg_t"); - } else { - msg->msg_type = MM_RADIO_MSG_DESTROY; - g_async_queue_push_front(radio->msg_queue, msg); - pthread_join(radio->msg.thread, NULL); - radio->msg.thread = 0; + if (p_thread->thread) { + switch (type) { + case MM_RADIO_THREAD_MSG: + msg = g_slice_new0(mm_radio_msg_t); + if (!msg) { + MMRADIO_LOG_ERROR("failed to get mm_radio_msg_t"); + } else { + msg->msg_type = MM_RADIO_MSG_DESTROY; + g_async_queue_push_front(radio->msg_queue, msg); + pthread_join(p_thread->thread, NULL); + p_thread->thread = 0; + } + break; + case MM_RADIO_THREAD_SEEK: + case MM_RADIO_THREAD_SCAN: + MMRADIO_THREAD_LOCK(p_thread); + p_thread->thread_exit = true; + MMRADIO_THREAD_SIGNAL(p_thread); + MMRADIO_THREAD_UNLOCK(p_thread); + pthread_join(p_thread->thread, NULL); + p_thread->thread = 0; + break; + default: + MMRADIO_LOG_WARNING("(%d)type isn't handled", type); + break; } + } else { + MMRADIO_LOG_WARNING("(%d)thread is zero", type); } + pthread_mutex_destroy(&p_thread->mutex); + pthread_cond_destroy(&p_thread->cond); + + MMRADIO_LOG_FLEAVE(); +} + +static void __mmradio_destroy_threads(mm_radio_t *radio) +{ + int type = (int)MM_RADIO_THREAD_NUM; + MMRADIO_LOG_FENTER(); + + MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio); + + while (--type >= 0) + __mmradio_destroy_thread_type(radio, (MMRadioThreadTypes)type); + pthread_mutex_destroy(&radio->cmd_lock); pthread_mutex_destroy(&radio->volume_lock); pthread_mutex_destroy(&radio->hal_seek_mutex); - pthread_mutex_destroy(&radio->seek.mutex); - pthread_cond_destroy(&radio->seek.cond); - - pthread_mutex_destroy(&radio->scan.mutex); - pthread_cond_destroy(&radio->scan.cond); - MMRADIO_LOG_FLEAVE(); } @@ -1630,18 +1687,33 @@ void __mmradio_msg_push(mm_radio_t *radio, MMRadioMsgTypes msg_type, int msg_dat void __mmradio_msg_thread(mm_radio_t *radio) { - MMMessageParamType param = {0,}; + mm_radio_msg_t *msg = NULL; - int exit_msg_thread = 0; + MMRadioThread_t *p_thread = NULL; + + MMRADIO_LOG_FENTER(); + MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio); + + p_thread = &radio->thread[MM_RADIO_THREAD_MSG]; + MMRADIO_CHECK_ARG_RETURN_VOID(p_thread); + + p_thread->thread_exit = false; - /*we run a while one loop*/ - while (exit_msg_thread == 0) { + + MMRADIO_THREAD_LOCK(p_thread); + MMRADIO_THREAD_SIGNAL(p_thread); + MMRADIO_THREAD_UNLOCK(p_thread); + + /* we run a while one loop*/ + while (!p_thread->thread_exit) { msg = (mm_radio_msg_t *)g_async_queue_pop(radio->msg_queue); if (!msg) { MMRADIO_LOG_ERROR("poped message is NULL!"); break; } + MMMessageParamType param = {0,}; + switch (msg->msg_type) { case MM_RADIO_MSG_DESTROY: MMRADIO_LOG_INFO("get destroy msg. pop all event to finish this thread"); @@ -1652,7 +1724,7 @@ void __mmradio_msg_thread(mm_radio_t *radio) g_slice_free(mm_radio_msg_t, msg_pop); } } - exit_msg_thread = 1; + p_thread->thread_exit = true; break; case MM_RADIO_MSG_SCAN_INFO: MMRADIO_LOG_INFO("get scan info frequency: %d", msg->data); @@ -1691,4 +1763,6 @@ void __mmradio_msg_thread(mm_radio_t *radio) } MMRADIO_LOG_INFO("msg thread is finished"); + MMRADIO_LOG_FLEAVE(); + pthread_exit(NULL); }