Sync rebase with tizen 2.3

Change-Id: I2c8707af077216b7d44d3ec0e64e04e28be1efa8

diff --git a/src/include/mm_radio_priv.h b/src/include/mm_radio_priv.h
index 419316e..402da56 100644 (file)
--- a/src/include/mm_radio_priv.h
+++ b/src/include/mm_radio_priv.h
@@ -139,6 +139,7 @@ typedef struct _mm_radio_gstreamer_s
        GstElement *pipeline;
        GstElement *avsysaudiosrc;
        GstElement *queue2;
+       GstElement *volume;
        GstElement *avsysaudiosink;
        GstBuffer *output_buffer;
 } mm_radio_gstreamer_s;
@@ -213,6 +214,7 @@ int _mmradio_stop(mm_radio_t* radio);
 int _mmradio_seek(mm_radio_t* radio, MMRadioSeekDirectionType direction);
 int _mmradio_start_scan(mm_radio_t* radio);
 int _mmradio_stop_scan(mm_radio_t* radio);
+int _mm_radio_get_signal_strength(mm_radio_t* radio, int *value);
 #ifdef USE_GST_PIPELINE
 int _mmradio_realize_pipeline( mm_radio_t* radio);
 int _mmradio_start_pipeline(mm_radio_t* radio);

diff --git a/src/include/mm_radio_utils.h b/src/include/mm_radio_utils.h
index b873483..84277ec 100644 (file)
--- a/src/include/mm_radio_utils.h
+++ b/src/include/mm_radio_utils.h
@@ -18,7 +18,7 @@
  * limitations under the License.
  *
  */
- 
+
 #ifndef __MM_RADIO_UTILS_H__
 #define __MM_RADIO_UTILS_H__
 
@@ -34,7 +34,6 @@
 #define MMRADIO_LOG_ERROR              debug_error
 #define MMRADIO_LOG_WARNING    debug_warning
 #define MMRADIO_LOG_CRITICAL   debug_critical
-#define MMRADIO_SLOG_DEBUG             secure_debug_log
 
 /* general */
 #ifndef ARRAY_SIZE

diff --git a/src/mm_radio_asm.c b/src/mm_radio_asm.c
index 8f3d59e..d049610 100644 (file)
--- a/src/mm_radio_asm.c
+++ b/src/mm_radio_asm.c
@@ -24,15 +24,14 @@
 #include "mm_radio_asm.h"
 #include "mm_radio_utils.h"
 
-static ASM_sound_events_t __mmradio_asm_get_event_type(int type);
-
 int mmradio_asm_register(MMRadioASM* sm, ASM_sound_cb_t callback, void* param)
 {
-       /* read mm-session type */
-       int sessionType = MM_SESSION_TYPE_SHARE;
+       /* read mm-session information */
+       int session_type = MM_SESSION_TYPE_MEDIA;
+       int session_options = 0;
        int errorcode = MM_ERROR_NONE;
        int asm_handle = -1;
-       int event_type = ASM_EVENT_NONE;
+       int event_type = ASM_EVENT_MEDIA_FMRADIO;
        int pid = -1;
 
        MMRADIO_LOG_FENTER();
@@ -43,32 +42,21 @@ int mmradio_asm_register(MMRadioASM* sm, ASM_sound_cb_t callback, void* param)
                return MM_ERROR_RADIO_NOT_INITIALIZED;
        }
 
-       /* read session type */
-       errorcode = _mm_session_util_read_type(-1, &sessionType);
-       if ( errorcode )
-       {
-               MMRADIO_LOG_WARNING("Read MMSession Type failed. use default \"exclusive\" type\n");
-               sessionType = MM_SESSION_TYPE_EXCLUSIVE;
-
-               /* init session */
-               errorcode = mm_session_init(sessionType);
+       /* read session information */
+       errorcode = _mm_session_util_read_information(pid, &session_type, &session_options);
                if ( errorcode )
                {
-                               MMRADIO_LOG_CRITICAL("mm_session_init() failed\n");
-                               return errorcode;
-               }
+               debug_warning("Read Session Information failed. use default \"media\" type\n");
+               session_type = MM_SESSION_TYPE_MEDIA;
        }
 
-       /* check if it's CALL */
-       if ( sessionType == MM_SESSION_TYPE_CALL || sessionType == MM_SESSION_TYPE_VIDEOCALL)
+       /* check if it's MEDIA type */
+       if ( session_type != MM_SESSION_TYPE_MEDIA)
        {
-               MMRADIO_LOG_DEBUG("session type is VOICE or VIDEO CALL (%d)\n", sessionType);
-               return MM_ERROR_NONE;
+               MMRADIO_LOG_DEBUG("session type is not MEDIA (%d)\n", session_type);
+               return MM_ERROR_RADIO_INTERNAL;
        }
 
-       /* interpret session type */
-       event_type = __mmradio_asm_get_event_type(sessionType);
-
        /* check if it's running on the media_server */
        if ( sm->pid > 0 )
        {
@@ -86,6 +74,15 @@ int mmradio_asm_register(MMRadioASM* sm, ASM_sound_cb_t callback, void* param)
                MMRADIO_LOG_CRITICAL("ASM_register_sound() failed\n");
                return errorcode;
        }
+       /* set session options */
+       if (session_options)
+       {
+               if( ! ASM_set_session_option(asm_handle, session_options, &errorcode))
+               {
+                       debug_error("ASM_set_session_options() failed, error(%x)\n", errorcode);
+                       return errorcode;
+               }
+       }
 
        /* now succeded to register our callback. take result */
        sm->handle = asm_handle;
@@ -98,8 +95,7 @@ int mmradio_asm_register(MMRadioASM* sm, ASM_sound_cb_t callback, void* param)
 
 int mmradio_asm_deregister(MMRadioASM* sm)
 {
-       int sessionType = MM_SESSION_TYPE_SHARE;
-       int event_type = ASM_EVENT_NONE;
+       int event_type = ASM_EVENT_MEDIA_FMRADIO;
        int errorcode = 0;
 
        MMRADIO_LOG_FENTER();
@@ -110,24 +106,6 @@ int mmradio_asm_deregister(MMRadioASM* sm)
                return MM_ERROR_RADIO_NOT_INITIALIZED;
        }
 
-       /* read session type */
-       errorcode = _mm_session_util_read_type(-1, &sessionType);
-       if ( errorcode )
-       {
-               MMRADIO_LOG_ERROR("MMSessionReadType Fail %s\n",__func__);
-               return MM_ERROR_POLICY_INTERNAL;
-       }
-
-       /* check if it's CALL */
-       if ( sessionType == MM_SESSION_TYPE_CALL || sessionType == MM_SESSION_TYPE_VIDEOCALL)
-       {
-               MMRADIO_LOG_DEBUG("session type is VOICE or VIDEO CALL (%d)\n", sessionType);
-               return MM_ERROR_NONE;
-       }
-
-       /* interpret session type */
-       event_type = __mmradio_asm_get_event_type(sessionType);
-
        if( ! ASM_unregister_sound( sm->handle, event_type, &errorcode) )
        {
                MMRADIO_LOG_ERROR("Unregister sound failed 0x%X\n", errorcode);
@@ -141,9 +119,7 @@ int mmradio_asm_deregister(MMRadioASM* sm)
 
 int mmradio_asm_set_state(MMRadioASM* sm, ASM_sound_states_t state, ASM_resource_t resource)
 {
-       int sessionType = MM_SESSION_TYPE_SHARE;
-       int event_type = ASM_EVENT_NONE;
-       int errorcode = 0;
+       int event_type = ASM_EVENT_MEDIA_FMRADIO;
 
        MMRADIO_LOG_FENTER();
 
@@ -153,27 +129,10 @@ int mmradio_asm_set_state(MMRadioASM* sm, ASM_sound_states_t state, ASM_resource
                return MM_ERROR_RADIO_NOT_INITIALIZED;
        }
 
-       /* read session type */
-       errorcode = _mm_session_util_read_type(-1, &sessionType);
-       if ( errorcode )
-       {
-               MMRADIO_LOG_ERROR("MMSessionReadType Fail\n");
-               return MM_ERROR_POLICY_INTERNAL;
-       }
-
-       /* check if it's CALL */
-       if ( sessionType == MM_SESSION_TYPE_CALL || sessionType == MM_SESSION_TYPE_VIDEOCALL )
-       {
-               MMRADIO_LOG_DEBUG("session type is VOICE or VIDEO CALL (%d)\n", sessionType);
-               return MM_ERROR_NONE;
-       }
-
        if ( sm->by_asm_cb == MMRADIO_ASM_CB_NONE ) //|| sm->state == ASM_STATE_PLAYING )
        {
                int ret = 0;
 
-               event_type = __mmradio_asm_get_event_type(sessionType);
-
                if( ! ASM_set_sound_state( sm->handle, event_type, state, resource, &ret) )
                {
                        MMRADIO_LOG_ERROR("set ASM state to [%d] failed 0x%X\n", state, ret);
@@ -193,37 +152,3 @@ int mmradio_asm_set_state(MMRadioASM* sm, ASM_sound_states_t state, ASM_resource
        return MM_ERROR_NONE;
 }
 
-
-ASM_sound_events_t __mmradio_asm_get_event_type(int type)
-{
-       int event_type = ASM_EVENT_NONE;
-
-       MMRADIO_LOG_FENTER();
-
-       /* interpret session type */
-       switch(type)
-       {
-               case MM_SESSION_TYPE_SHARE:
-                       event_type = ASM_EVENT_SHARE_FMRADIO;
-               break;
-
-               case MM_SESSION_TYPE_EXCLUSIVE:
-                       event_type = ASM_EVENT_EXCLUSIVE_FMRADIO;
-               break;
-
-               case MM_SESSION_TYPE_ALARM:
-                       event_type = ASM_EVENT_ALARM;
-               break;
-
-               case MM_SESSION_TYPE_NOTIFY:
-               case MM_SESSION_TYPE_CALL:
-               case MM_SESSION_TYPE_VIDEOCALL:
-               default:
-                       MMRADIO_LOG_CRITICAL("unexpected case! (%d)\n", type);
-                       assert(0);
-       }
-
-       MMRADIO_LOG_FLEAVE();
-
-       return event_type;
-}

diff --git a/src/mm_radio_priv.c b/src/mm_radio_priv.c
index d2bb2df..b662cfd 100755 (executable)
--- a/src/mm_radio_priv.c
+++ b/src/mm_radio_priv.c
@@ -18,7 +18,7 @@
  * limitations under the License.
  *
  */
- 
+
 /*===========================================================================================
 |                                                                                                                                                                                      |
 |  INCLUDE FILES                                                                                                                                                       |
@@ -70,7 +70,7 @@
 #define DEFAULT_WRAP_AROUND                    1 //If non-zero, wrap around when at the end of the frequency range, else stop seeking
 
 #define RADIO_DEFAULT_REGION                   MM_RADIO_REGION_GROUP_USA
-
+#define READ_MAX_BUFFER_SIZE 1024
 /*---------------------------------------------------------------------------
     LOCAL CONSTANT DEFINITIONS:
 ---------------------------------------------------------------------------*/
@@ -201,7 +201,7 @@ _mmradio_create_radio(mm_radio_t* radio)
        int ret  = 0;
 
        MMRADIO_LOG_FENTER();
-               
+
        MMRADIO_CHECK_INSTANCE( radio );
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_CREATE );
 
@@ -238,6 +238,7 @@ int
 _mmradio_realize(mm_radio_t* radio)
 {
        int ret = MM_ERROR_NONE;
+       char str_error[READ_MAX_BUFFER_SIZE];
 
        MMRADIO_LOG_FENTER();
 
@@ -255,14 +256,14 @@ _mmradio_realize(mm_radio_t* radio)
                if (radio->radio_fd < 0)
                {
                        MMRADIO_LOG_ERROR("failed to open radio device[%s] because of %s(%d)\n",
-                                               DEFAULT_DEVICE, strerror(errno), errno);
-                       
+                                               DEFAULT_DEVICE, strerror_r(errno, str_error, sizeof(str_error)), errno);
+
                        /* check error */
                        switch (errno)
                        {
                                case ENOENT:
                                        return MM_ERROR_RADIO_DEVICE_NOT_FOUND;
-                               case EACCES:                                    
+                               case EACCES:
                                        return MM_ERROR_RADIO_PERMISSION_DENIED;
                                default:
                                        return MM_ERROR_RADIO_DEVICE_NOT_OPENED;
@@ -349,7 +350,7 @@ int
 _mmradio_unrealize(mm_radio_t* radio)
 {
        int ret = MM_ERROR_NONE;
-       
+
        MMRADIO_LOG_FENTER();
 
        MMRADIO_CHECK_INSTANCE( radio );
@@ -384,10 +385,10 @@ _mmradio_destroy(mm_radio_t* radio)
 {
        int ret = 0;
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_DESTROY );
-       
+
        ret = mmradio_asm_deregister(&radio->sm);
        if ( ret )
        {
@@ -417,7 +418,7 @@ _mmradio_set_frequency(mm_radio_t* radio, int freq) // unit should be KHz
 
        if (radio->radio_fd < 0)
        {
-               MMRADIO_LOG_DEBUG("radio device is not opened yet. so, it will be applied\n", freq);
+               MMRADIO_LOG_DEBUG("radio device is not opened yet\n");
                return MM_ERROR_NONE;
        }
 
@@ -439,9 +440,9 @@ _mmradio_set_frequency(mm_radio_t* radio, int freq) // unit should be KHz
        }
 
        MMRADIO_LOG_FLEAVE();
-       
+
        return MM_ERROR_NONE;
-       
+
 }
 
 int
@@ -467,7 +468,7 @@ _mmradio_get_frequency(mm_radio_t* radio, int* pFreq)
        {
                MMRADIO_LOG_ERROR("failed to do VIDIOC_G_FREQUENCY\n");
                return MM_ERROR_RADIO_INTERNAL;
-       }       
+       }
 
        freq = RADIO_FREQ_FORMAT_GET((radio->vf).frequency);
 
@@ -485,14 +486,14 @@ int
 _mmradio_mute(mm_radio_t* radio)
 {
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_MUTE );
 
        if (radio->radio_fd < 0)
        {
                return MM_ERROR_RADIO_NOT_INITIALIZED;
-       }       
+       }
 
        (radio->vctrl).id = V4L2_CID_AUDIO_MUTE;
        (radio->vctrl).value = 1; //mute
@@ -503,16 +504,16 @@ _mmradio_mute(mm_radio_t* radio)
        }
 
        MMRADIO_LOG_FLEAVE();
-       
+
        return MM_ERROR_NONE;
-       
+
 }
 
 int
 _mmradio_unmute(mm_radio_t* radio)
 {
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_UNMUTE );
        MMRADIO_CHECK_DEVICE_STATE( radio );
@@ -541,7 +542,7 @@ int
 __mmradio_set_deemphasis(mm_radio_t* radio)
 {
        int value = 0;
-       
+
        MMRADIO_LOG_FENTER();
 
        MMRADIO_CHECK_INSTANCE( radio );
@@ -611,29 +612,29 @@ int
 _mmradio_set_message_callback(mm_radio_t* radio, MMMessageCallback callback, void *user_param)
 {
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
 
        radio->msg_cb = callback;
        radio->msg_cb_param = user_param;
 
-       MMRADIO_LOG_DEBUG("msg_cb : 0x%p msg_cb_param : 0x%p\n", callback, user_param);
+       MMRADIO_LOG_DEBUG("msg_cb : 0x%x msg_cb_param : 0x%x\n", (unsigned int)callback, (unsigned int)user_param);
 
        MMRADIO_LOG_FLEAVE();
 
        return MM_ERROR_NONE;
 }
-               
+
 int
 _mmradio_get_state(mm_radio_t* radio, int* pState)
 {
        int state = 0;
 
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
        return_val_if_fail( pState, MM_ERROR_INVALID_ARGUMENT );
-               
+
        state = __mmradio_get_state( radio );
 
        *pState = state;
@@ -647,9 +648,9 @@ int
 _mmradio_start(mm_radio_t* radio)
 {
        int ret = MM_ERROR_NONE;
-       
+
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_START );
 
@@ -689,7 +690,7 @@ _mmradio_stop(mm_radio_t* radio)
        int ret = MM_ERROR_NONE;
 
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_STOP );
 
@@ -841,15 +842,15 @@ int
 _mmradio_seek(mm_radio_t* radio, MMRadioSeekDirectionType direction)
 {
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_SEEK );
 
        int ret = 0;
-       
+
        if( _mmradio_mute(radio) != MM_ERROR_NONE)
                return MM_ERROR_RADIO_NOT_INITIALIZED;
-               
+
        MMRADIO_LOG_DEBUG("trying to seek. direction[0:UP/1:DOWN) %d\n", direction);
        radio->seek_direction = direction;
 
@@ -876,13 +877,13 @@ _mmradio_start_scan(mm_radio_t* radio)
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_START_SCAN );
 
        int scan_tr_id = 0;
-       
+
        radio->stop_scan = false;
 
        scan_tr_id = pthread_create(&radio->scan_thread, NULL,
                (void *)__mmradio_scan_thread, (void *)radio);
 
-       if (scan_tr_id != 0) 
+       if (scan_tr_id != 0)
        {
                MMRADIO_LOG_DEBUG("failed to create thread : scan\n");
                return MM_ERROR_RADIO_NOT_INITIALIZED;
@@ -899,14 +900,14 @@ int
 _mmradio_stop_scan(mm_radio_t* radio)
 {
        MMRADIO_LOG_FENTER();
-       
+
        MMRADIO_CHECK_INSTANCE( radio );
        MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_STOP_SCAN );
-               
+
        radio->stop_scan = true;
 
        if( radio->scan_thread > 0 )
-       {       
+       {
                pthread_cancel(radio->scan_thread);
                pthread_join(radio->scan_thread, NULL);
                radio->scan_thread = 0;
@@ -916,7 +917,7 @@ _mmradio_stop_scan(mm_radio_t* radio)
        MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_STOP, NULL);
 
        MMRADIO_LOG_FLEAVE();
-       
+
        return MM_ERROR_NONE;
 }
 
@@ -931,7 +932,7 @@ _mm_radio_get_signal_strength(mm_radio_t* radio, int *value)
        /* just return stored frequency if radio device is not ready */
        if ( radio->radio_fd < 0 )
        {
-               MMRADIO_SLOG_DEBUG("Device not ready so sending 0\n");
+               MMRADIO_LOG_DEBUG("Device not ready so sending 0\n");
                *value = 0;
                return MM_ERROR_NONE;
        }
@@ -950,6 +951,8 @@ __mmradio_scan_thread(mm_radio_t* radio)
 {
        int ret = 0;
        int prev_freq = 0;
+       char str_error[READ_MAX_BUFFER_SIZE];
+
        struct v4l2_hw_freq_seek vs = {0,};
        vs.tuner = TUNER_INDEX;
        vs.type = V4L2_TUNER_RADIO;
@@ -989,7 +992,7 @@ __mmradio_scan_thread(mm_radio_t* radio)
                        }
                        else
                        {
-                               MMRADIO_LOG_ERROR("Error: %s, %d\n", strerror(errno), errno);
+                               MMRADIO_LOG_ERROR("Error: %s, %d\n", strerror_r(errno, str_error, sizeof(str_error)), errno);
                                break;
                        }
                }
@@ -1016,7 +1019,7 @@ __mmradio_scan_thread(mm_radio_t* radio)
 
                        prev_freq = param.radio_scan.frequency = freq;
                        MMRADIO_LOG_DEBUG("scanning : new frequency : [%d]\n", param.radio_scan.frequency);
-                       
+
                        /* drop if max freq is scanned */
                        if (param.radio_scan.frequency == radio->region_setting.band_max )
                        {
@@ -1031,7 +1034,7 @@ __mmradio_scan_thread(mm_radio_t* radio)
        }
 FINISHED:
        radio->scan_thread = 0;
-       
+
        MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
 
        if ( ! radio->stop_scan )
@@ -1046,7 +1049,7 @@ FINISHED:
        return;
 }
 
-bool 
+bool
 __is_tunable_frequency(mm_radio_t* radio, int freq)
 {
        MMRADIO_LOG_FENTER();
@@ -1066,6 +1069,7 @@ __mmradio_seek_thread(mm_radio_t* radio)
 {
        int ret = 0;
        int freq = 0;
+       char str_error[READ_MAX_BUFFER_SIZE];
        bool seek_stop = false;
        MMMessageParamType param = {0,};
        struct v4l2_hw_freq_seek vs = {0,};
@@ -1091,9 +1095,9 @@ __mmradio_seek_thread(mm_radio_t* radio)
        MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SEEK_START, NULL);
 
        MMRADIO_LOG_DEBUG("seeking....\n");
-       
+
        while (  ! seek_stop )
-       {       
+       {
                ret = ioctl( radio->radio_fd, VIDIOC_S_HW_FREQ_SEEK, &vs );
 
                if( ret == -1 )
@@ -1111,7 +1115,7 @@ __mmradio_seek_thread(mm_radio_t* radio)
                        }
                        else
                        {
-                               MMRADIO_LOG_ERROR("Error: %s, %d\n", strerror(errno), errno);
+                               MMRADIO_LOG_ERROR("Error: %s, %d\n", strerror_r(errno, str_error, sizeof(str_error)), errno);
                                goto SEEK_FAILED;
                        }
                }
@@ -1124,12 +1128,12 @@ __mmradio_seek_thread(mm_radio_t* radio)
                        goto SEEK_FAILED;
                }
 
-               MMRADIO_LOG_DEBUG("found frequency = %d\n", freq);
+               MMRADIO_LOG_DEBUG("found frequency\n");
 
                /* 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 one(%d). So, trying next one. \n", freq);
+                       MMRADIO_LOG_DEBUG("It's same with previous found one. So, trying next one. \n");
                        continue;
                }
 
@@ -1144,9 +1148,9 @@ __mmradio_seek_thread(mm_radio_t* radio)
                        }
                }
 
-               /* now turn on radio 
-                 * In the case of limit freq, tuner should be unmuted. 
-                 * Otherwise, sound can't output even though application set new frequency. 
+               /* now turn on radio
+                 * In the case of limit freq, tuner should be unmuted.
+                 * Otherwise, sound can't output even though application set new frequency.
                  */
                ret = _mmradio_unmute(radio);
                if ( ret )
@@ -1427,9 +1431,9 @@ __mmradio_asm_callback(int handle, ASM_event_sources_t event_source, ASM_sound_c
                                case ASM_EVENT_SOURCE_EARJACK_UNPLUG:
                                case ASM_EVENT_SOURCE_MEDIA:
                                {
-                                       radio->sm.by_asm_cb = MMRADIO_ASM_CB_POSTMSG;                                   
+                                       radio->sm.by_asm_cb = MMRADIO_ASM_CB_POSTMSG;
                                        result = _mmradio_stop(radio);
-                                       if( result ) 
+                                       if( result )
                                        {
                                                MMRADIO_LOG_ERROR("failed to stop radio\n");
                                        }
@@ -1441,19 +1445,12 @@ __mmradio_asm_callback(int handle, ASM_event_sources_t event_source, ASM_sound_c
                                case ASM_EVENT_SOURCE_RESOURCE_CONFLICT:
                                default:
                                {
-                                       radio->sm.by_asm_cb = MMRADIO_ASM_CB_SKIP_POSTMSG;                                      
+                                       radio->sm.by_asm_cb = MMRADIO_ASM_CB_POSTMSG;
                                        result = _mmradio_stop(radio);
-                                       if( result ) 
+                                       if( result )
                                        {
                                                MMRADIO_LOG_ERROR("failed to stop radio\n");
                                        }
-
-                                       radio->sm.by_asm_cb = MMRADIO_ASM_CB_POSTMSG;
-                                       result = _mmradio_unrealize(radio);
-                                       if ( result ) 
-                                       {
-                                               MMRADIO_LOG_ERROR("failed to unrealize radio\n");
-                                       }
                                }
                                break;
                        }

diff --git a/test/mm_radio_testsuite.c b/test/mm_radio_testsuite.c
index d9b50cf..b798d53 100755 (executable)
--- a/test/mm_radio_testsuite.c
+++ b/test/mm_radio_testsuite.c
@@ -259,7 +259,6 @@ int __test_radio_listen_gorealra(void)
        RADIO_TEST__( mm_radio_realize(radio); )
        RADIO_TEST__( mm_radio_set_frequency( radio, DEFAULT_TEST_FREQ ); )
        RADIO_TEST__( mm_radio_start(radio); )
-
        return ret;
 }