}
}
- MMRADIO_LOG_DEBUG("setting region - country: %d, de-emphasis: %d, band range: %d ~ %d KHz\n",
+ MMRADIO_LOG_DEBUG("setting region - country: %d, de-emphasis: %d, band range: %d ~ %d KHz",
radio->region_setting.country, radio->region_setting.deemphasis,
radio->region_setting.band_min, radio->region_setting.band_max);
/* create command lock */
ret = pthread_mutex_init(&radio->cmd_lock, NULL);
if (ret) {
- MMRADIO_LOG_ERROR("mutex creation failed\n");
+ MMRADIO_LOG_ERROR("mutex creation failed");
return MM_ERROR_RADIO_INTERNAL;
}
ret = pthread_mutex_init(&radio->volume_lock, NULL);
if (ret) {
- MMRADIO_LOG_ERROR("volume mutex creation failed\n");
+ MMRADIO_LOG_ERROR("volume mutex creation failed");
return MM_ERROR_RADIO_INTERNAL;
}
if (ret) {
/* NOTE : we are dealing it as an error since we cannot expect it's behavior */
- MMRADIO_LOG_ERROR("mmradio_audio_focus_register is failed\n");
+ MMRADIO_LOG_ERROR("mmradio_audio_focus_register is failed");
return MM_ERROR_RADIO_INTERNAL;
}
#endif
ret = radio_hal_interface_init(&(radio->hal_inf));
if (ret) {
- MMRADIO_LOG_ERROR("mmradio hal interface init failed\n");
+ MMRADIO_LOG_ERROR("mmradio hal interface init failed");
return ret;
}
ret = radio_hal_interface_deinit(radio->hal_inf);
if (ret) {
- MMRADIO_LOG_ERROR("mmradio hal interface deinit failed\n");
+ MMRADIO_LOG_ERROR("mmradio hal interface deinit failed");
return ret;
}
#ifdef TIZEN_FEATURE_SOUND_FOCUS
ret = mmradio_sound_focus_deregister(&radio->sound_focus);
if (ret) {
- MMRADIO_LOG_ERROR("failed to deregister sound focus\n");
+ MMRADIO_LOG_ERROR("failed to deregister sound focus");
return MM_ERROR_RADIO_INTERNAL;
}
#endif
MMRADIO_CHECK_INSTANCE(radio);
MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_FREQ);
- MMRADIO_LOG_DEBUG("Setting %d frequency\n", freq);
+ MMRADIO_LOG_DEBUG("Setting %d frequency", freq);
radio->freq = freq;
radio->msg_cb = callback;
radio->msg_cb_param = user_param;
- MMRADIO_LOG_DEBUG("msg_cb : 0x%x msg_cb_param : 0x%x\n", callback, user_param);
+ MMRADIO_LOG_DEBUG("msg_cb : 0x%x msg_cb_param : 0x%x", callback, user_param);
MMRADIO_LOG_FLEAVE();
MMRADIO_CHECK_INSTANCE(radio);
MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_START);
- MMRADIO_LOG_DEBUG("now tune to frequency : %d\n", radio->freq);
+ MMRADIO_LOG_DEBUG("now tune to frequency : %d", radio->freq);
#ifdef TIZEN_FEATURE_SOUND_FOCUS
if (radio->sound_focus.handle > 0) {
if (ret == MM_ERROR_NOT_SUPPORT_API) {
MMRADIO_LOG_WARNING("radio_hal_start is not supported");
} else if (ret) {
- MMRADIO_LOG_ERROR("failed to radio_hal_start\n");
+ MMRADIO_LOG_ERROR("failed to radio_hal_start");
goto error1;
}
/* set stored frequency */
ret = radio_hal_set_frequency(radio->hal_inf, radio->freq);
if (ret) {
- MMRADIO_LOG_ERROR("failed to radio_hal_set_frequency\n");
+ MMRADIO_LOG_ERROR("failed to radio_hal_set_frequency");
goto error1;
}
#ifdef TIZEN_FEATURE_SOUND_VSTREAM
ret = sound_manager_start_virtual_stream(radio->vstream);
if (ret) {
- MMRADIO_LOG_ERROR("failed to sound_manager_start_virtual_stream\n");
+ MMRADIO_LOG_ERROR("failed to sound_manager_start_virtual_stream");
goto error;
}
#endif
if (ret == MM_ERROR_NOT_SUPPORT_API) {
MMRADIO_LOG_WARNING("radio_hal_unmute is not supported");
} else if (ret) {
- MMRADIO_LOG_ERROR("failed to radio_hal_stop\n");
+ MMRADIO_LOG_ERROR("failed to radio_hal_stop");
return ret;
}
if (radio->sound_focus.handle > 0) {
ret = mmradio_release_sound_focus(&radio->sound_focus);
if (ret) {
- MMRADIO_LOG_ERROR("mmradio_release_audio_focus is failed\n");
+ MMRADIO_LOG_ERROR("mmradio_release_audio_focus is failed");
return ret;
}
}
if (ret == MM_ERROR_NOT_SUPPORT_API) {
MMRADIO_LOG_WARNING("radio_hal_mute is not supported");
} else if (ret) {
- MMRADIO_LOG_ERROR("failed to radio_hal_mute\n");
+ MMRADIO_LOG_ERROR("failed to radio_hal_mute");
return ret;
}
radio->seek_unmute = TRUE;
}
- MMRADIO_LOG_DEBUG("trying to seek. direction[0:UP/1:DOWN) %d\n", direction);
+ MMRADIO_LOG_DEBUG("trying to seek. direction[0:UP/1:DOWN) %d", direction);
radio->seek_direction = direction;
ret = pthread_create(&radio->seek_thread, NULL, (void *)__mmradio_seek_thread, (void *)radio);
if (ret) {
- MMRADIO_LOG_DEBUG("failed create thread\n");
+ MMRADIO_LOG_DEBUG("failed create thread");
radio->is_seeking = FALSE;
radio->seek_cancel = TRUE;
if (radio->seek_unmute) {
if (ret == MM_ERROR_NOT_SUPPORT_API) {
MMRADIO_LOG_WARNING("radio_hal_mute is not supported");
} else if (ret) {
- MMRADIO_LOG_ERROR("failed to radio_hal_mute\n");
+ MMRADIO_LOG_ERROR("failed to radio_hal_mute");
radio->seek_unmute = FALSE;
return ret;
}
scan_tr_id = pthread_create(&radio->scan_thread, NULL, (void *)__mmradio_scan_thread, (void *)radio);
if (scan_tr_id != 0) {
- MMRADIO_LOG_DEBUG("failed to create thread : scan\n");
+ MMRADIO_LOG_DEBUG("failed to create thread : scan");
return MM_ERROR_RADIO_NOT_INITIALIZED;
}
if (ret == MM_ERROR_NOT_SUPPORT_API) {
MMRADIO_LOG_WARNING("radio_hal_unmute is not supported");
} else if (ret != MM_ERROR_NONE) {
- debug_error("radio_hal_get_signal_strength error\n");
+ debug_error("radio_hal_get_signal_strength error");
*value = 0;
MMRADIO_LOG_FLEAVE();
return ret;
uint32_t freq = 0;
MMMessageParamType param = { 0, };
- MMRADIO_LOG_DEBUG("scanning....\n");
+ MMRADIO_LOG_DEBUG("scanning....");
pthread_mutex_lock(&radio->seek_cancel_mutex);
ret = radio_hal_get_frequency(radio->hal_inf, &freq);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("failed to get current frequency\n");
+ MMRADIO_LOG_ERROR("failed to get current frequency");
} else {
if (freq < prev_freq) {
- MMRADIO_LOG_DEBUG("scanning wrapped around. stopping scan\n");
+ MMRADIO_LOG_DEBUG("scanning wrapped around. stopping scan");
break;
}
continue;
prev_freq = param.radio_scan.frequency = (int)freq;
- MMRADIO_LOG_DEBUG("scanning : new frequency : [%d]\n", param.radio_scan.frequency);
+ MMRADIO_LOG_DEBUG("scanning : new frequency : [%d]", param.radio_scan.frequency);
/* drop if max freq is scanned */
if (param.radio_scan.frequency == radio->region_setting.band_max) {
- MMRADIO_LOG_DEBUG("%d freq is dropping...and stopping scan\n", param.radio_scan.frequency);
+ MMRADIO_LOG_DEBUG("%d freq is dropping...and stopping scan", param.radio_scan.frequency);
break;
}
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SEEK_START, NULL);
- MMRADIO_LOG_DEBUG("seeking....\n");
+ MMRADIO_LOG_DEBUG("seeking....");
if (!radio->seek_cancel) {
MMRADIO_LOG_DEBUG("try to seek ");
pthread_mutex_lock(&radio->seek_cancel_mutex);
- MMRADIO_LOG_DEBUG("seek start\n");
+ MMRADIO_LOG_DEBUG("seek start");
if (radio->seek_cancel) {
MMRADIO_LOG_DEBUG("seek was canceled so we return failure to application");
ret = radio_hal_seek(radio->hal_inf, radio->seek_direction);
pthread_mutex_unlock(&radio->seek_cancel_mutex);
if (ret) {
- MMRADIO_LOG_ERROR("radio_hal_seek failed\n");
+ MMRADIO_LOG_ERROR("radio_hal_seek failed");
goto SEEK_FAILED;
}
/* now we can get new frequency from radio device */
ret = radio_hal_get_frequency(radio->hal_inf, &freq);
if (ret) {
- MMRADIO_LOG_ERROR("failed to get current frequency\n");
+ MMRADIO_LOG_ERROR("failed to get current frequency");
goto SEEK_FAILED;
}
- MMRADIO_LOG_DEBUG("found frequency\n");
+ MMRADIO_LOG_DEBUG("found frequency");
/* if same freq is found, ignore it and search next one. */
if (freq == radio->prev_seek_freq) {
- MMRADIO_LOG_DEBUG("It's same with previous found one. So, trying next one. \n");
+ MMRADIO_LOG_DEBUG("It's same with previous found one. So, trying next one.");
goto SEEK_FAILED;
}
/* now tune to new frequency */
ret = radio_hal_set_frequency(radio->hal_inf, freq);
if (ret) {
- MMRADIO_LOG_ERROR("failed to tune to new frequency\n");
+ MMRADIO_LOG_ERROR("failed to tune to new frequency");
goto SEEK_FAILED;
}
}
*/
ret = radio_hal_unmute(radio->hal_inf);
if (ret) {
- MMRADIO_LOG_ERROR("failed to tune to new frequency\n");
+ MMRADIO_LOG_ERROR("failed to tune to new frequency");
goto SEEK_FAILED;
}
radio->seek_unmute = FALSE;
}
param.radio_scan.frequency = radio->prev_seek_freq = (int)freq;
- MMRADIO_LOG_DEBUG("seeking : new frequency : [%d]\n", param.radio_scan.frequency);
+ MMRADIO_LOG_DEBUG("seeking : new frequency : [%d]", param.radio_scan.frequency);
MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SEEK_FINISH, ¶m);
}
*/
ret = radio_hal_unmute(radio->hal_inf);
if (ret)
- MMRADIO_LOG_ERROR("failed to tune to new frequency\n");
+ MMRADIO_LOG_ERROR("failed to tune to new frequency");
radio->seek_unmute = FALSE;
}
/* freq -1 means it's failed to seek */
MMRADIO_LOG_FENTER();
if (!radio->msg_cb) {
- debug_warning("failed to post a message\n");
+ debug_warning("failed to post a message");
return false;
}
- MMRADIO_LOG_DEBUG("address of msg_cb : %p\n", radio->msg_cb);
+ MMRADIO_LOG_DEBUG("address of msg_cb : %p", radio->msg_cb);
radio->msg_cb(msgtype, param, radio->msg_cb_param);
radio_state = __mmradio_get_state(radio);
- MMRADIO_LOG_DEBUG("incomming command : %d current state : %d\n", command, radio_state);
+ MMRADIO_LOG_DEBUG("incomming command : %d current state : %d", command, radio_state);
switch (command) {
case MMRADIO_COMMAND_CREATE:
break;
default:
- MMRADIO_LOG_DEBUG("not handled in FSM. don't care it\n");
+ MMRADIO_LOG_DEBUG("not handled in FSM. don't care it");
break;
}
- MMRADIO_LOG_DEBUG("status OK\n");
+ MMRADIO_LOG_DEBUG("status OK");
radio->cmd = command;
return MM_ERROR_NONE;
INVALID_STATE:
- debug_warning("invalid state. current : %d command : %d\n", radio_state, command);
+ debug_warning("invalid state. current : %d command : %d", radio_state, command);
MMRADIO_LOG_FLEAVE();
return MM_ERROR_RADIO_INVALID_STATE;
NO_OP:
- debug_warning("mm-radio is in the desired state(%d). doing noting\n", radio_state);
+ debug_warning("mm-radio is in the desired state(%d). doing noting", radio_state);
MMRADIO_LOG_FLEAVE();
return MM_ERROR_RADIO_NO_OP;
MMRADIO_LOG_FENTER();
if (!radio) {
- debug_warning("calling set_state with invalid radio handle\n");
+ debug_warning("calling set_state with invalid radio handle");
return false;
}
if (radio->current_state == new_state && radio->pending_state == 0) {
- debug_warning("we are in same state\n");
+ debug_warning("we are in same state");
return true;
}
{
MMRADIO_CHECK_INSTANCE(radio);
- MMRADIO_LOG_DEBUG("radio state : current : [%d] old : [%d] pending : [%d]\n",
+ MMRADIO_LOG_DEBUG("radio state : current : [%d] old : [%d] pending : [%d]",
radio->current_state, radio->old_state, radio->pending_state);
return radio->current_state;
result = _mmradio_stop(radio);
if (result)
- MMRADIO_LOG_ERROR("failed to stop radio\n");
+ MMRADIO_LOG_ERROR("failed to stop radio");
- MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED cur_focus_type : %d\n", radio->sound_focus.cur_focus_type);
+ MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED cur_focus_type : %d", radio->sound_focus.cur_focus_type);
}
break;
radio->sound_focus.by_focus_cb = MMRADIO_FOCUS_CB_NONE;
- MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED cur_focus_type : %d\n", radio->sound_focus.cur_focus_type);
+ MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED cur_focus_type : %d", radio->sound_focus.cur_focus_type);
}
break;
default:
- MMRADIO_LOG_DEBUG("Unknown focus_state\n");
+ MMRADIO_LOG_DEBUG("Unknown focus_state");
break;
}
result = _mmradio_stop(radio);
if (result)
- MMRADIO_LOG_ERROR("failed to stop radio\n");
+ MMRADIO_LOG_ERROR("failed to stop radio");
MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED cur_focus_type : %d\n", radio->sound_focus.cur_focus_type);
}
radio->sound_focus.by_focus_cb = MMRADIO_FOCUS_CB_NONE;
- MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED cur_focus_type : %d\n", radio->sound_focus.cur_focus_type);
+ MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED cur_focus_type : %d", radio->sound_focus.cur_focus_type);
}
break;
default:
- MMRADIO_LOG_DEBUG("Unknown focus_state\n");
+ MMRADIO_LOG_DEBUG("Unknown focus_state");
break;
}
MMRADIO_CHECK_INSTANCE(radio);
MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_VOLUME);
- MMRADIO_LOG_DEBUG("Setting %f volume\n", volume);
+ MMRADIO_LOG_DEBUG("Setting %f volume", volume);
MMRADIO_VOLUME_LOCK(radio);
radio->local_volume = volume;
MMRADIO_CHECK_INSTANCE(radio);
MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_VOLUME);
- MMRADIO_LOG_DEBUG("Setting %d volume\n", level);
+ MMRADIO_LOG_DEBUG("Setting %d volume", level);
MMRADIO_VOLUME_LOCK(radio);
radio->media_volume = level;
result = _mmradio_stop(radio);
if (result != MM_ERROR_NONE)
- MMRADIO_LOG_ERROR("failed to stop radio\n");
+ MMRADIO_LOG_ERROR("failed to stop radio");
}
break;
default:
MMRADIO_LOG_FENTER();
if (!sound_focus) {
- MMRADIO_LOG_ERROR("invalid session handle\n");
+ MMRADIO_LOG_ERROR("invalid session handle");
return MM_ERROR_RADIO_NOT_INITIALIZED;
}
sound_focus->cur_focus_type = FOCUS_NONE;
ret = _mm_session_util_read_information(pid, &session_type, &session_flags);
MMRADIO_LOG_DEBUG("Read Session type ret:0x%X", ret);
if (ret == MM_ERROR_INVALID_HANDLE) {
- MMRADIO_LOG_WARNING("subscribe_id=%d\n", sound_focus->subscribe_id);
+ MMRADIO_LOG_WARNING("subscribe_id=%d", sound_focus->subscribe_id);
if (sound_focus->subscribe_id == 0) {
ret = mm_sound_subscribe_signal_for_daemon(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, pid, &sound_focus->subscribe_id,
(mm_sound_signal_callback)_mmradio_sound_signal_callback, (void*)sound_focus);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_subscribe_signal is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_subscribe_signal is failed");
return MM_ERROR_POLICY_BLOCKED;
}
- MMRADIO_LOG_DEBUG("register mm_sound_subscribe_signal_for_daemon subscribe_id %d\n", sound_focus->subscribe_id);
+ MMRADIO_LOG_DEBUG("register mm_sound_subscribe_signal_for_daemon subscribe_id %d", sound_focus->subscribe_id);
/* register watch callback */
ret = mm_sound_set_focus_watch_callback_for_session(pid,
FOCUS_FOR_BOTH, watch_cb, (void *)param, &sound_focus->watch_id);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_set_focus_watch_callback is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_set_focus_watch_callback is failed");
return MM_ERROR_POLICY_BLOCKED;
}
MMRADIO_LOG_DEBUG("(%p) set focus watch callback = %d", param, sound_focus->watch_id);
ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
(mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void *)param, &sound_focus->device_subs_id);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed");
return MM_ERROR_POLICY_BLOCKED;
}
- MMRADIO_LOG_ERROR("register device connected callback for the value is 0, sub_cb id %d\n", sound_focus->device_subs_id);
+ MMRADIO_LOG_ERROR("register device connected callback for the value is 0, sub_cb id %d", sound_focus->device_subs_id);
}
ret = MM_ERROR_NONE;
} else if (ret == MM_ERROR_NONE) {
- MMRADIO_LOG_WARNING("Read Session Information success. session_type : %d flags: %d \n", session_type, session_flags);
+ MMRADIO_LOG_WARNING("Read Session Information success. session_type : %d flags: %d", session_type, session_flags);
sound_focus->session_type = session_type;
sound_focus->snd_session_flags = session_flags;
if (sound_focus->session_type == MM_SESSION_TYPE_MEDIA) {
ret = mm_sound_register_focus_for_session(handle, pid, "radio", focus_cb, param);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_DEBUG("mm_sound_register_focus_for_session is failed\n");
+ MMRADIO_LOG_DEBUG("mm_sound_register_focus_for_session is failed");
return MM_ERROR_POLICY_BLOCKED;
}
MMRADIO_LOG_DEBUG("(%p) register focus for session %d", param, pid);
ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
(mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void *)param, &sound_focus->device_subs_id);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed");
return MM_ERROR_POLICY_BLOCKED;
}
MMRADIO_LOG_DEBUG("(%p) add device connected callback = %d", param, sound_focus->device_subs_id);
ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
(mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void*)param, &sound_focus->device_subs_id);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed");
return MM_ERROR_POLICY_BLOCKED;
}
MMRADIO_LOG_DEBUG("add device connected callback = %d", sound_focus->device_subs_id);
ret = mm_sound_set_focus_watch_callback_for_session(pid,
FOCUS_FOR_BOTH, watch_cb, (void*)param, &sound_focus->watch_id);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_set_focus_watch_callback is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_set_focus_watch_callback is failed");
return MM_ERROR_POLICY_BLOCKED;
}
MMRADIO_LOG_DEBUG("set focus watch callback = %d", sound_focus->watch_id);
ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
(mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void*)param, &sound_focus->device_subs_id);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed");
return MM_ERROR_POLICY_BLOCKED;
}
MMRADIO_LOG_DEBUG("(%p) add device connected callback = %d", param, sound_focus->device_subs_id);
}
ret = MM_ERROR_NONE;
} else {
- MMRADIO_LOG_WARNING("Read Session Information failed. skip sound focus register function. errorcode %x \n", ret);
+ MMRADIO_LOG_WARNING("Read Session Information failed. skip sound focus register function. errorcode %x", ret);
}
MMRADIO_LOG_FLEAVE();
MMRADIO_LOG_FENTER();
if (!sound_focus) {
- MMRADIO_LOG_ERROR("invalid session handle\n");
+ MMRADIO_LOG_ERROR("invalid session handle");
return MM_ERROR_RADIO_NOT_INITIALIZED;
}
mm_sound_focus_type_e focus_type = FOCUS_NONE;
MMRADIO_LOG_FENTER();
- MMRADIO_LOG_ERROR("mmradio_acquire_sound_focus sound_focus->cur_focus_type : %d\n", sound_focus->cur_focus_type);
+ MMRADIO_LOG_ERROR("mmradio_acquire_sound_focus sound_focus->cur_focus_type : %d", sound_focus->cur_focus_type);
focus_type = FOCUS_FOR_BOTH & ~(sound_focus->cur_focus_type);
if (focus_type != FOCUS_NONE) {
ret = mm_sound_acquire_focus(sound_focus->handle, focus_type, NULL);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_acquire_focus is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_acquire_focus is failed");
return MM_ERROR_POLICY_BLOCKED;
}
sound_focus->cur_focus_type = FOCUS_FOR_BOTH;
int ret = MM_ERROR_NONE;
MMRADIO_LOG_FENTER();
- MMRADIO_LOG_ERROR("mmradio_release_sound_focus sound_focus->cur_focus_type : %d\n", sound_focus->cur_focus_type);
+ MMRADIO_LOG_ERROR("mmradio_release_sound_focus sound_focus->cur_focus_type : %d", sound_focus->cur_focus_type);
if (sound_focus->cur_focus_type != FOCUS_NONE) {
ret = mm_sound_release_focus(sound_focus->handle, sound_focus->cur_focus_type, NULL);
if (ret != MM_ERROR_NONE) {
- MMRADIO_LOG_ERROR("mm_sound_release_focus is failed\n");
+ MMRADIO_LOG_ERROR("mm_sound_release_focus is failed");
return MM_ERROR_POLICY_BLOCKED;
}
sound_focus->cur_focus_type = FOCUS_NONE;
void mmradio_get_sound_focus_reason(mm_sound_focus_state_e focus_state, const char *reason_for_change, bool is_watch, enum MMMessageInterruptedCode *event_source, int *postMsg)
{
MMRADIO_LOG_FENTER();
- MMRADIO_LOG_ERROR("mmradio_get_sound_focus_reason focus_state : %d reason_for_change :%s\n", focus_state, reason_for_change);
+ MMRADIO_LOG_ERROR("mmradio_get_sound_focus_reason focus_state : %d reason_for_change :%s", focus_state, reason_for_change);
if (0 == strncmp(reason_for_change, "call-voice", AUDIO_FOCUS_REASON_MAX)
|| (0 == strncmp(reason_for_change, "voip", AUDIO_FOCUS_REASON_MAX))