When creating a thread, waiting for the thread function to start

[Version] 0.2.38
[Profile] Mobile, Wearable
[Issue Type] Fix bugs

Change-Id: I5f8cc010267a0b95882996e981fbf65bd33f6385

1 files changed, 206 insertions, 132 deletions

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);
 }