X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fradio.c;h=9e5313c644b3ad5e7c69d16fb545bf1527ce5e92;hb=79a36932e8510bd09d51ff10f641ca1fb7cb49f5;hp=4b085b30effd2b4e9d165d78c9538d6385096b1d;hpb=e6cbe37cfbcffb232548c8a74577d50022701b93;p=platform%2Fcore%2Fapi%2Fradio.git diff --git a/src/radio.c b/src/radio.c old mode 100644 new mode 100755 index 4b085b3..9e5313c --- a/src/radio.c +++ b/src/radio.c @@ -11,7 +11,7 @@ * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and -* limitations under the License. +* limitations under the License. */ #include @@ -21,7 +21,7 @@ #include #include #include - +#include #ifdef LOG_TAG #undef LOG_TAG @@ -31,18 +31,26 @@ /* * Internal Macros */ -#define RADIO_CHECK_CONDITION(condition,error,msg) \ - if(condition) {} else \ - { LOGE("[%s] %s(0x%08x)",(char*)__FUNCTION__, msg,error); return error;}; \ +#define RADIO_CHECK_CONDITION(condition, error, msg) \ + do { \ + if (condition) { \ + } else { \ + LOGE("[%s] %s(0x%08x)", (char *)__FUNCTION__, msg, error); \ + return error; \ + } \ + } while (0) #define RADIO_INSTANCE_CHECK(radio) \ - RADIO_CHECK_CONDITION(radio != NULL, RADIO_ERROR_INVALID_PARAMETER,"RADIO_ERROR_INVALID_PARAMETER") - -#define RADIO_STATE_CHECK(radio,expected_state) \ - RADIO_CHECK_CONDITION(radio->state == expected_state,RADIO_ERROR_INVALID_STATE,"RADIO_ERROR_INVALID_STATE") + RADIO_CHECK_CONDITION(radio != NULL, RADIO_ERROR_INVALID_PARAMETER, "RADIO_ERROR_INVALID_PARAMETER") + +#define RADIO_STATE_CHECK(radio, expected_state) \ + RADIO_CHECK_CONDITION(radio->state == expected_state, RADIO_ERROR_INVALID_STATE, "RADIO_ERROR_INVALID_STATE") #define RADIO_NULL_ARG_CHECK(arg) \ - RADIO_CHECK_CONDITION(arg != NULL,RADIO_ERROR_INVALID_PARAMETER,"RADIO_ERROR_INVALID_PARAMETER") + RADIO_CHECK_CONDITION(arg != NULL, RADIO_ERROR_INVALID_PARAMETER, "RADIO_ERROR_INVALID_PARAMETER") + +#define RADIO_SUPPORT_CHECK(arg) \ + RADIO_CHECK_CONDITION(arg != false, RADIO_ERROR_NOT_SUPPORTED, "RADIO_ERROR_NOT_SUPPORTED") /* * Internal Implementation @@ -50,182 +58,242 @@ static int __convert_error_code(int code, char *func_name) { int ret = RADIO_ERROR_NONE; - char* msg="RADIO_ERROR_NONE"; - switch(code) - { - case MM_ERROR_NONE: - ret = RADIO_ERROR_NONE; - msg = "RADIO_ERROR_NONE"; - break; - - case MM_ERROR_RADIO_NO_FREE_SPACE: - ret = RADIO_ERROR_OUT_OF_MEMORY; - msg = "RADIO_ERROR_OUT_OF_MEMORY"; - break; - case MM_ERROR_RADIO_NOT_INITIALIZED: - case MM_ERROR_RADIO_NO_OP: - ret = RADIO_ERROR_INVALID_STATE; - msg = "RADIO_ERROR_INVALID_STATE"; - break; - case MM_ERROR_COMMON_INVALID_ARGUMENT: - ret = RADIO_ERROR_INVALID_PARAMETER; - msg = "RADIO_ERROR_INVALID_PARAMETER"; - break; - case MM_ERROR_POLICY_BLOCKED: - case MM_ERROR_POLICY_INTERRUPTED: - case MM_ERROR_POLICY_INTERNAL: - case MM_ERROR_POLICY_DUPLICATED: - ret = RADIO_ERROR_SOUND_POLICY; - msg = "RADIO_ERROR_SOUND_POLICY"; - break; - case MM_ERROR_RADIO_INTERNAL: - case MM_ERROR_RADIO_RESPONSE_TIMEOUT: - case MM_ERROR_RADIO_DEVICE_NOT_OPENED: - case MM_ERROR_RADIO_DEVICE_NOT_FOUND: - default : - ret= RADIO_ERROR_INVALID_OPERATION; - msg = "RADIO_ERROR_INVALID_OPERATION"; - } - LOGE("[%s] %s(0x%08x) : core fw error(0x%x)",func_name,msg, ret, code); - return ret; + char *msg = "RADIO_ERROR_NONE"; + LOGI("[%s] Enter code :%x", __func__, code); + switch (code) { + case MM_ERROR_NONE: + ret = RADIO_ERROR_NONE; + msg = "RADIO_ERROR_NONE"; + break; + + case MM_ERROR_RADIO_NO_FREE_SPACE: + ret = RADIO_ERROR_OUT_OF_MEMORY; + msg = "RADIO_ERROR_OUT_OF_MEMORY"; + break; + case MM_ERROR_RADIO_NOT_INITIALIZED: + case MM_ERROR_RADIO_NO_OP: + case MM_ERROR_RADIO_INVALID_STATE: + ret = RADIO_ERROR_INVALID_STATE; + msg = "RADIO_ERROR_INVALID_STATE"; + break; + case MM_ERROR_COMMON_INVALID_ARGUMENT: + case MM_ERROR_INVALID_ARGUMENT: + ret = RADIO_ERROR_INVALID_PARAMETER; + msg = "RADIO_ERROR_INVALID_PARAMETER"; + break; + case MM_ERROR_POLICY_BLOCKED: + case MM_ERROR_POLICY_INTERRUPTED: + case MM_ERROR_POLICY_INTERNAL: + case MM_ERROR_POLICY_DUPLICATED: + ret = RADIO_ERROR_SOUND_POLICY; + msg = "RADIO_ERROR_SOUND_POLICY"; + break; + case MM_ERROR_RADIO_INTERNAL: + case MM_ERROR_RADIO_RESPONSE_TIMEOUT: + ret = RADIO_ERROR_INVALID_OPERATION; + msg = "RADIO_ERROR_INVALID_OPERATION"; + break; + case MM_ERROR_RADIO_DEVICE_NOT_FOUND: + ret = RADIO_ERROR_NOT_SUPPORTED; + msg = "RADIO_ERROR_NOT_SUPPORTED"; + break; + case MM_ERROR_RADIO_NO_ANTENNA: + ret = RADIO_ERROR_NO_ANTENNA; + msg = "RADIO_ERROR_NO_ANTENNA"; + break; + case MM_ERROR_RADIO_DEVICE_NOT_OPENED: + default: + ret = RADIO_ERROR_PERMISSION_DENIED; + msg = "RADIO_ERROR_PERMISSION_DENIED"; + } + LOGE("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code); + return ret; } static radio_state_e __convert_radio_state(MMRadioStateType state) { int converted_state = RADIO_STATE_READY; - switch(state) - { - - case MM_RADIO_STATE_PLAYING: - converted_state = RADIO_STATE_PLAYING; - break; - case MM_RADIO_STATE_SCANNING: - converted_state = RADIO_STATE_SCANNING; - break; - case MM_RADIO_STATE_NULL: - case MM_RADIO_STATE_READY: - default: - converted_state = RADIO_STATE_READY; - break; - } + LOGI("[%s] Enter state: %d", __func__, state); + switch (state) { + + case MM_RADIO_STATE_PLAYING: + converted_state = RADIO_STATE_PLAYING; + break; + case MM_RADIO_STATE_SCANNING: + converted_state = RADIO_STATE_SCANNING; + break; + case MM_RADIO_STATE_NULL: + case MM_RADIO_STATE_READY: + default: + converted_state = RADIO_STATE_READY; + break; + } + LOGI("[%s] Leave converted_state: %d", __func__, converted_state); return converted_state; } -static int __set_callback(_radio_event_e type, radio_h radio, void* callback, void *user_data) +static radio_interrupted_code_e __convert_interrupted_code(int code) +{ + LOGI("[%s] Enter code: %d", __func__, code); + radio_interrupted_code_e ret = RADIO_INTERRUPTED_BY_RESOURCE_CONFLICT; + switch (code) { + case MM_MSG_CODE_INTERRUPTED_BY_CALL_END: + case MM_MSG_CODE_INTERRUPTED_BY_ALARM_END: + case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END: + case MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_END: + ret = RADIO_INTERRUPTED_COMPLETED; + break; + case MM_MSG_CODE_INTERRUPTED_BY_MEDIA: + case MM_MSG_CODE_INTERRUPTED_BY_OTHER_PLAYER_APP: + ret = RADIO_INTERRUPTED_BY_MEDIA; + break; + case MM_MSG_CODE_INTERRUPTED_BY_CALL_START: + ret = RADIO_INTERRUPTED_BY_CALL; + break; + case MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG: + ret = RADIO_INTERRUPTED_BY_EARJACK_UNPLUG; + break; + case MM_MSG_CODE_INTERRUPTED_BY_ALARM_START: + ret = RADIO_INTERRUPTED_BY_ALARM; + break; + case MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_START: + ret = RADIO_INTERRUPTED_BY_NOTIFICATION; + break; + case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START: + ret = RADIO_INTERRUPTED_BY_EMERGENCY; + break; + case MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT: + default: + ret = RADIO_INTERRUPTED_BY_RESOURCE_CONFLICT; + break; + } + LOGE("[%s] interrupted code(%d) => ret(%d)", __FUNCTION__, code, ret); + return ret; +} + +static int __set_callback(_radio_event_e type, radio_h radio, void *callback, void *user_data) { RADIO_INSTANCE_CHECK(radio); RADIO_NULL_ARG_CHECK(callback); - radio_s * handle = (radio_s *) radio; + radio_s *handle = (radio_s *)radio; handle->user_cb[type] = callback; handle->user_data[type] = user_data; - LOGI("[%s] Event type : %d ",__FUNCTION__, type); - return RADIO_ERROR_NONE; + LOGI("[%s] Event type : %d ", __FUNCTION__, type); + return RADIO_ERROR_NONE; } static int __unset_callback(_radio_event_e type, radio_h radio) { RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; + radio_s *handle = (radio_s *)radio; handle->user_cb[type] = NULL; handle->user_data[type] = NULL; - LOGI("[%s] Event type : %d ",__FUNCTION__, type); - return RADIO_ERROR_NONE; + LOGI("[%s] Event type : %d ", __FUNCTION__, type); + return RADIO_ERROR_NONE; } static int __msg_callback(int message, void *param, void *user_data) { - radio_s * handle = (radio_s*)user_data; - MMMessageParamType *msg = (MMMessageParamType*)param; - LOGI("[%s] Got message type : 0x%x" ,__FUNCTION__, message); - switch(message) - { - case MM_MESSAGE_RADIO_SCAN_INFO: - if( handle->user_cb[_RADIO_EVENT_TYPE_SCAN_INFO] ) - { - ((radio_scan_updated_cb)handle->user_cb[_RADIO_EVENT_TYPE_SCAN_INFO])(msg->radio_scan.frequency,handle->user_data[_RADIO_EVENT_TYPE_SCAN_INFO]); - } - break; - case MM_MESSAGE_RADIO_SCAN_STOP: - if( handle->user_cb[_RADIO_EVENT_TYPE_SCAN_STOP] ) - { - ((radio_scan_stopped_cb)handle->user_cb[_RADIO_EVENT_TYPE_SCAN_STOP])(handle->user_data[_RADIO_EVENT_TYPE_SCAN_STOP]); - } - break; - case MM_MESSAGE_RADIO_SCAN_FINISH: - if( handle->user_cb[_RADIO_EVENT_TYPE_SCAN_FINISH] ) - { - ((radio_scan_completed_cb)handle->user_cb[_RADIO_EVENT_TYPE_SCAN_FINISH])(handle->user_data[_RADIO_EVENT_TYPE_SCAN_FINISH]); - } - break; - case MM_MESSAGE_RADIO_SEEK_FINISH: - if( handle->user_cb[_RADIO_EVENT_TYPE_SEEK_FINISH] ) - { - ((radio_seek_completed_cb)handle->user_cb[_RADIO_EVENT_TYPE_SEEK_FINISH])(msg->radio_scan.frequency, handle->user_data[_RADIO_EVENT_TYPE_SEEK_FINISH]); - } - break; - case MM_MESSAGE_STATE_INTERRUPTED: - if( handle->user_cb[_RADIO_EVENT_TYPE_INTERRUPT] ) - { - ((radio_interrupted_cb)handle->user_cb[_RADIO_EVENT_TYPE_INTERRUPT])(msg->code,handle->user_data[_RADIO_EVENT_TYPE_INTERRUPT]); - } - break; - case MM_MESSAGE_ERROR: - __convert_error_code(msg->code,(char*)__FUNCTION__); - break; - case MM_MESSAGE_RADIO_SCAN_START: - LOGI("[%s] Scan Started"); - break; - case MM_MESSAGE_STATE_CHANGED: - handle->state = __convert_radio_state(msg->state.current); - LOGI("[%s] State Changed --- from : %d , to : %d" ,__FUNCTION__, __convert_radio_state(msg->state.previous), handle->state); - break; - case MM_MESSAGE_RADIO_SEEK_START: - LOGI("[%s] Seek Started", __FUNCTION__); - break; - default: - break; + radio_s *handle = (radio_s *)user_data; + MMMessageParamType *msg = (MMMessageParamType *)param; + LOGI("[%s] Got message type : 0x%x", __FUNCTION__, message); + switch (message) { + case MM_MESSAGE_RADIO_SCAN_INFO: + if (handle->user_cb[_RADIO_EVENT_TYPE_SCAN_INFO]) + ((radio_scan_updated_cb)handle->user_cb[_RADIO_EVENT_TYPE_SCAN_INFO])(msg->radio_scan.frequency, handle->user_data[_RADIO_EVENT_TYPE_SCAN_INFO]); + break; + case MM_MESSAGE_RADIO_SCAN_STOP: + if (handle->user_cb[_RADIO_EVENT_TYPE_SCAN_STOP]) + ((radio_scan_stopped_cb)handle->user_cb[_RADIO_EVENT_TYPE_SCAN_STOP])(handle->user_data[_RADIO_EVENT_TYPE_SCAN_STOP]); + break; + case MM_MESSAGE_RADIO_SCAN_FINISH: + if (handle->user_cb[_RADIO_EVENT_TYPE_SCAN_FINISH]) + ((radio_scan_completed_cb)handle->user_cb[_RADIO_EVENT_TYPE_SCAN_FINISH])(handle->user_data[_RADIO_EVENT_TYPE_SCAN_FINISH]); + break; + case MM_MESSAGE_RADIO_SEEK_FINISH: + if (handle->user_cb[_RADIO_EVENT_TYPE_SEEK_FINISH]) + ((radio_seek_completed_cb)handle->user_cb[_RADIO_EVENT_TYPE_SEEK_FINISH])(msg->radio_scan.frequency, handle->user_data[_RADIO_EVENT_TYPE_SEEK_FINISH]); + break; + case MM_MESSAGE_STATE_INTERRUPTED: + if (handle->user_cb[_RADIO_EVENT_TYPE_INTERRUPT]) + ((radio_interrupted_cb)handle->user_cb[_RADIO_EVENT_TYPE_INTERRUPT])(__convert_interrupted_code(msg->code), handle->user_data[_RADIO_EVENT_TYPE_INTERRUPT]); + break; + case MM_MESSAGE_READY_TO_RESUME: + if (handle->user_cb[_RADIO_EVENT_TYPE_INTERRUPT]) + ((radio_interrupted_cb)handle->user_cb[_RADIO_EVENT_TYPE_INTERRUPT])(RADIO_INTERRUPTED_COMPLETED, handle->user_data[_RADIO_EVENT_TYPE_INTERRUPT]); + break; + case MM_MESSAGE_ERROR: + __convert_error_code(msg->code, (char *)__FUNCTION__); + break; + case MM_MESSAGE_RADIO_SCAN_START: + LOGI("[%s] Scan Started"); + break; + case MM_MESSAGE_STATE_CHANGED: + handle->state = __convert_radio_state(msg->state.current); + LOGI("[%s] State Changed --- from : %d , to : %d", __FUNCTION__, __convert_radio_state(msg->state.previous), handle->state); + break; + case MM_MESSAGE_RADIO_SEEK_START: + LOGI("[%s] Seek Started", __FUNCTION__); + break; + default: + break; } return 1; } +static int __radio_check_system_info_feature_supported() +{ + bool bValue = false; + int nRetVal = false; + + nRetVal = system_info_get_platform_bool("http://tizen.org/feature/fmradio", &bValue); + + if (nRetVal != SYSTEM_INFO_ERROR_NONE) { + LOGE("[%s] SYSTEM_INFO_ERROR : ", __FUNCTION__); + return false; + } + + if (false == bValue) + LOGI("system_info_get_platform_bool returned Unsupported feature capability\n"); + else + LOGI("system_info_get_platform_bool returned Supported status feature\n"); + + return bValue; +} /* * Public Implementation */ int radio_create(radio_h *radio) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle; - handle = (radio_s*)malloc( sizeof(radio_s)); - if (handle != NULL) - memset(handle, 0 , sizeof(radio_s)); - else - { - LOGE("[%s] RADIO_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__,RADIO_ERROR_OUT_OF_MEMORY); + radio_s *handle; + + handle = (radio_s *)malloc(sizeof(radio_s)); + if (handle != NULL) { + memset(handle, 0, sizeof(radio_s)); + } else { + LOGE("[%s] RADIO_ERROR_OUT_OF_MEMORY(0x%08x)", __FUNCTION__, RADIO_ERROR_OUT_OF_MEMORY); return RADIO_ERROR_OUT_OF_MEMORY; } int ret = mm_radio_create(&handle->mm_handle); - if( ret != MM_ERROR_NONE) - { - LOGE("[%s] RADIO_ERROR_INVALID_OPERATION(0x%08x)" ,__FUNCTION__,RADIO_ERROR_INVALID_OPERATION); + if (ret != MM_ERROR_NONE) { free(handle); - handle=NULL; - return RADIO_ERROR_INVALID_OPERATION; - } - else - { + handle = NULL; + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { *radio = (radio_h)handle; - - ret = mm_radio_set_message_callback(handle->mm_handle, __msg_callback, (void*)handle); - if(ret != MM_ERROR_NONE) - { - LOGW("[%s] Failed to set message callback function (0x%x)" ,__FUNCTION__, ret); - } + + ret = mm_radio_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle); + if (ret != MM_ERROR_NONE) + LOGW("[%s] Failed to set message callback function (0x%x)", __FUNCTION__, ret); + ret = mm_radio_realize(handle->mm_handle); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } + if (ret != MM_ERROR_NONE) + return __convert_error_code(ret, (char *)__FUNCTION__); + handle->state = RADIO_STATE_READY; handle->mute = FALSE; return RADIO_ERROR_NONE; @@ -234,45 +302,40 @@ int radio_create(radio_h *radio) int radio_destroy(radio_h radio) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; + radio_s *handle = (radio_s *)radio; int ret; ret = mm_radio_unrealize(handle->mm_handle); - if ( ret!= MM_ERROR_NONE) - { - LOGW("[%s] Failed to unrealize (0x%x)" ,__FUNCTION__, ret); - } - + if (ret != MM_ERROR_NONE) + LOGW("[%s] Failed to unrealize (0x%x)", __FUNCTION__, ret); + ret = mm_radio_destroy(handle->mm_handle); - if (ret!= MM_ERROR_NONE) - { - LOGE("[%s] RADIO_ERROR_INVALID_OPERATION (0x%08x)" ,__FUNCTION__,RADIO_ERROR_INVALID_OPERATION); - return RADIO_ERROR_INVALID_OPERATION; - } - else - { + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { free(handle); - handle= NULL; + handle = NULL; return RADIO_ERROR_NONE; } } -int radio_get_state(radio_h radio, radio_state_e *state) +int radio_get_state(radio_h radio, radio_state_e *state) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); RADIO_NULL_ARG_CHECK(state); - radio_s * handle = (radio_s *) radio; + radio_s *handle = (radio_s *)radio; MMRadioStateType currentStat = MM_RADIO_STATE_NULL; int ret = mm_radio_get_state(handle->mm_handle, ¤tStat); - if(ret != MM_ERROR_NONE) - { + if (ret != MM_ERROR_NONE) { *state = handle->state; - return __convert_error_code(ret,(char*)__FUNCTION__); - } - else - { - handle->state = __convert_radio_state(currentStat); + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { + handle->state = __convert_radio_state(currentStat); *state = handle->state; return RADIO_ERROR_NONE; } @@ -280,17 +343,16 @@ int radio_get_state(radio_h radio, radio_state_e *state) int radio_start(radio_h radio) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; - RADIO_STATE_CHECK(handle,RADIO_STATE_READY); + radio_s *handle = (radio_s *)radio; + RADIO_STATE_CHECK(handle, RADIO_STATE_READY); int ret = mm_radio_start(handle->mm_handle); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } - else - { + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { handle->state = RADIO_STATE_PLAYING; return RADIO_ERROR_NONE; } @@ -298,126 +360,110 @@ int radio_start(radio_h radio) int radio_stop(radio_h radio) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; - RADIO_STATE_CHECK(handle,RADIO_STATE_PLAYING); - + radio_s *handle = (radio_s *)radio; + RADIO_STATE_CHECK(handle, RADIO_STATE_PLAYING); + int ret = mm_radio_stop(handle->mm_handle); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } - else - { + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { handle->state = RADIO_STATE_READY; return RADIO_ERROR_NONE; } } -int radio_seek_up(radio_h radio,radio_seek_completed_cb callback, void *user_data ) +int radio_seek_up(radio_h radio, radio_seek_completed_cb callback, void *user_data) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; - RADIO_STATE_CHECK(handle,RADIO_STATE_PLAYING); - - if(callback!=NULL) - { - __set_callback(_RADIO_EVENT_TYPE_SEEK_FINISH,radio,callback,user_data); - } + radio_s *handle = (radio_s *)radio; + RADIO_STATE_CHECK(handle, RADIO_STATE_PLAYING); + + if (callback != NULL) + __set_callback(_RADIO_EVENT_TYPE_SEEK_FINISH, radio, callback, user_data); else - { - __unset_callback(_RADIO_EVENT_TYPE_SEEK_FINISH,radio); - } - + __unset_callback(_RADIO_EVENT_TYPE_SEEK_FINISH, radio); + int ret = mm_radio_seek(handle->mm_handle, MM_RADIO_SEEK_UP); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } + if (ret != MM_ERROR_NONE) + return __convert_error_code(ret, (char *)__FUNCTION__); else - { return RADIO_ERROR_NONE; - } } -int radio_seek_down(radio_h radio,radio_seek_completed_cb callback, void *user_data ) +int radio_seek_down(radio_h radio, radio_seek_completed_cb callback, void *user_data) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; - RADIO_STATE_CHECK(handle,RADIO_STATE_PLAYING); - - if(callback!=NULL) - { - __set_callback(_RADIO_EVENT_TYPE_SEEK_FINISH,radio,callback,user_data); - } + radio_s *handle = (radio_s *)radio; + RADIO_STATE_CHECK(handle, RADIO_STATE_PLAYING); + + if (callback != NULL) + __set_callback(_RADIO_EVENT_TYPE_SEEK_FINISH, radio, callback, user_data); else - { - __unset_callback(_RADIO_EVENT_TYPE_SEEK_FINISH,radio); - } - + __unset_callback(_RADIO_EVENT_TYPE_SEEK_FINISH, radio); + int ret = mm_radio_seek(handle->mm_handle, MM_RADIO_SEEK_DOWN); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } + if (ret != MM_ERROR_NONE) + return __convert_error_code(ret, (char *)__FUNCTION__); else - { return RADIO_ERROR_NONE; - } } int radio_set_frequency(radio_h radio, int frequency) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - if(frequency < 87500 || frequency > 108000) - { - LOGE("[%s] RADIO_ERROR_INVALID_PARAMETER(0x%08x) : Out of range (87500 ~ 108000)" ,__FUNCTION__,RADIO_ERROR_INVALID_PARAMETER); + if (frequency < 87500 || frequency > 108000) { + LOGE("[%s] RADIO_ERROR_INVALID_PARAMETER(0x%08x) : Out of range (87500 ~ 108000)", __FUNCTION__, RADIO_ERROR_INVALID_PARAMETER); return RADIO_ERROR_INVALID_PARAMETER; } - int freq= frequency; - radio_s * handle = (radio_s *) radio; + int freq = frequency; + radio_s *handle = (radio_s *)radio; int ret = mm_radio_set_frequency(handle->mm_handle, freq); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } + if (ret != MM_ERROR_NONE) + return __convert_error_code(ret, (char *)__FUNCTION__); else - { return RADIO_ERROR_NONE; - } } int radio_get_frequency(radio_h radio, int *frequency) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; + RADIO_NULL_ARG_CHECK(frequency); + radio_s *handle = (radio_s *)radio; int freq; int ret = mm_radio_get_frequency(handle->mm_handle, &freq); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } - else - { - *frequency = freq; + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { + *frequency = freq; return RADIO_ERROR_NONE; } -} +} int radio_get_signal_strength(radio_h radio, int *strength) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; + RADIO_NULL_ARG_CHECK(strength); + radio_s *handle = (radio_s *)radio; int _strength; int ret = mm_radio_get_signal_strength(handle->mm_handle, &_strength); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } - else - { + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { *strength = _strength; return RADIO_ERROR_NONE; } @@ -425,26 +471,21 @@ int radio_get_signal_strength(radio_h radio, int *strength) int radio_scan_start(radio_h radio, radio_scan_updated_cb callback, void *user_data) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; - RADIO_STATE_CHECK(handle,RADIO_STATE_READY); + radio_s *handle = (radio_s *)radio; + RADIO_STATE_CHECK(handle, RADIO_STATE_READY); - if(callback!=NULL) - { - __set_callback(_RADIO_EVENT_TYPE_SCAN_INFO,radio,callback,user_data); - } + if (callback != NULL) + __set_callback(_RADIO_EVENT_TYPE_SCAN_INFO, radio, callback, user_data); else - { - __unset_callback(_RADIO_EVENT_TYPE_SCAN_INFO,radio); - } - + __unset_callback(_RADIO_EVENT_TYPE_SCAN_INFO, radio); + int ret = mm_radio_scan_start(handle->mm_handle); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } - else - { + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { handle->state = RADIO_STATE_SCANNING; return RADIO_ERROR_NONE; } @@ -452,44 +493,37 @@ int radio_scan_start(radio_h radio, radio_scan_updated_cb callback, void *user_d int radio_scan_stop(radio_h radio, radio_scan_stopped_cb callback, void *user_data) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; - RADIO_STATE_CHECK(handle,RADIO_STATE_SCANNING); + radio_s *handle = (radio_s *)radio; + RADIO_STATE_CHECK(handle, RADIO_STATE_SCANNING); - if(callback!=NULL) - { - __set_callback(_RADIO_EVENT_TYPE_SCAN_STOP,radio,callback,user_data); - } + if (callback != NULL) + __set_callback(_RADIO_EVENT_TYPE_SCAN_STOP, radio, callback, user_data); else - { - __unset_callback(_RADIO_EVENT_TYPE_SCAN_STOP,radio); - } - + __unset_callback(_RADIO_EVENT_TYPE_SCAN_STOP, radio); + int ret = mm_radio_scan_stop(handle->mm_handle); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } - else - { + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { handle->state = RADIO_STATE_READY; return RADIO_ERROR_NONE; } } - int radio_set_mute(radio_h radio, bool muted) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); - radio_s * handle = (radio_s *) radio; + radio_s *handle = (radio_s *)radio; int ret = mm_radio_set_mute(handle->mm_handle, muted); - if(ret != MM_ERROR_NONE) - { - return __convert_error_code(ret,(char*)__FUNCTION__); - } - else - { + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { handle->mute = muted; return RADIO_ERROR_NONE; } @@ -497,29 +531,77 @@ int radio_set_mute(radio_h radio, bool muted) int radio_is_muted(radio_h radio, bool *muted) { + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); RADIO_INSTANCE_CHECK(radio); RADIO_NULL_ARG_CHECK(muted); - radio_s * handle = (radio_s *) radio; + radio_s *handle = (radio_s *)radio; *muted = handle->mute; return RADIO_ERROR_NONE; } int radio_set_scan_completed_cb(radio_h radio, radio_scan_completed_cb callback, void *user_data) { - return __set_callback(_RADIO_EVENT_TYPE_SCAN_FINISH,radio,callback,user_data); + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); + return __set_callback(_RADIO_EVENT_TYPE_SCAN_FINISH, radio, callback, user_data); } int radio_unset_scan_completed_cb(radio_h radio) { - return __unset_callback(_RADIO_EVENT_TYPE_SCAN_FINISH,radio); + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); + return __unset_callback(_RADIO_EVENT_TYPE_SCAN_FINISH, radio); } int radio_set_interrupted_cb(radio_h radio, radio_interrupted_cb callback, void *user_data) { - return __set_callback(_RADIO_EVENT_TYPE_INTERRUPT,radio,callback,user_data); + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); + return __set_callback(_RADIO_EVENT_TYPE_INTERRUPT, radio, callback, user_data); } int radio_unset_interrupted_cb(radio_h radio) { - return __unset_callback(_RADIO_EVENT_TYPE_INTERRUPT,radio); + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); + return __unset_callback(_RADIO_EVENT_TYPE_INTERRUPT, radio); +} + +int radio_get_frequency_range(radio_h radio, int *min_freq, int *max_freq) +{ + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); + RADIO_INSTANCE_CHECK(radio); + RADIO_NULL_ARG_CHECK(min_freq); + RADIO_NULL_ARG_CHECK(max_freq); + radio_s *handle = (radio_s *)radio; + + unsigned int min = 0; + unsigned int max = 0; + + int ret = mm_radio_get_region_frequency_range(handle->mm_handle, &min, &max); + if (ret != MM_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } else { + *min_freq = min; + *max_freq = max; + return RADIO_ERROR_NONE; + } +} + +int radio_get_channel_spacing(radio_h radio, int *channel_spacing) +{ + LOGI("[%s] Enter", __func__); + RADIO_SUPPORT_CHECK(__radio_check_system_info_feature_supported()); + RADIO_INSTANCE_CHECK(radio); + + radio_s *handle = (radio_s *)radio; + + int ret = mm_radio_get_channel_spacing(handle->mm_handle, channel_spacing); + + if (ret != MM_ERROR_NONE) + return __convert_error_code(ret, (char *)__FUNCTION__); + else + return RADIO_ERROR_NONE; }