Name: libmm-radio
Summary: Multimedia Framework Radio Library
-Version: 0.2.1
+Version: 0.2.2
Release: 1
Group: System/Libraries
License: Apache-2.0
libmmfradio_la_SOURCES = mm_radio.c \
mm_radio_priv.c \
- mm_radio_asm.c
+ mm_radio_audio_focus.c
libmmfradio_la_CFLAGS = -I. -I./include \
$(GTHREAD_CFLAGS) \
* limitations under the License.
*
*/
-
-#ifndef MM_RADIO_ASM_H_
-#define MM_RADIO_ASM_H_
+
+#ifndef MM_RADIO_AUDIO_FOCUS_H_
+#define MM_RADIO_AUDIO_FOCUS_H_
#include <mm_types.h>
#include <mm_error.h>
#include <mm_session.h>
#include <mm_session_private.h>
#include <audio-session-manager.h>
+#include <mm_sound_focus.h>
enum {
MMRADIO_ASM_CB_NONE,
int pid;
int by_asm_cb;
int event_src;
- ASM_sound_states_t state;
-} MMRadioASM;
+ int sound_focus_register;
+ int asm_session_flags;
+} MMRadioAudioFocus;
-/* returns allocated handle */
-int mmradio_asm_register(MMRadioASM* sm, ASM_sound_cb_t callback, void* param);
-int mmradio_asm_deregister(MMRadioASM* sm);
-int mmradio_asm_set_state(MMRadioASM* sm, ASM_sound_states_t state, ASM_resource_t resource);
+int mmradio_audio_focus_register(MMRadioAudioFocus* sm, mm_sound_focus_changed_cb callback, void* param);
+int mmradio_audio_focus_deregister(MMRadioAudioFocus* sm);
+int mmradio_set_audio_focus(MMRadioAudioFocus* sm, mm_sound_focus_changed_watch_cb callback, void* param);
+int mmradio_unset_audio_focus(MMRadioAudioFocus* sm, void* param);
+void mmradio_get_audio_focus_reason(mm_sound_focus_state_e focus_state, const char *reason_for_change, ASM_event_sources_t *event_source, int *postMsg);
-#endif /* MM_RADIO_ASM_H_ */
+#endif /* MM_RADIO_AUDIO_FOCUS_H_ */
#include <mm_types.h>
#include <mm_message.h>
-#include "mm_radio_asm.h"
+#include "mm_radio_audio_focus.h"
#include "mm_radio.h"
#include "mm_radio_utils.h"
#include <linux/videodev2.h>
#include <gst/gst.h>
#include <gst/gstbuffer.h>
-
+
+#include <mm_sound.h>
+#include <mm_sound_focus.h>
+
#ifdef __cplusplus
extern "C" {
#endif
int prev_seek_freq;
MMRadioSeekDirectionType seek_direction;
- /* ASM */
- MMRadioASM sm;
+ MMRadioAudioFocus sm;
int freq;
#ifdef USE_GST_PIPELINE
int _mmradio_apply_region(mm_radio_t*radio, MMRadioRegionType region, bool update);
int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type);
int _mmradio_get_region_frequency_range(mm_radio_t* radio, unsigned int *min_freq, unsigned int *max_freq);
+int _mmradio_get_channel_spacing(mm_radio_t* radio, unsigned int *ch_spacing);
+void _mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
+ mm_sound_focus_state_e focus_state, const char *reason_for_change,
+ const char *additional_info, void *user_data);
+
+void _mmradio_sound_focus_watch_cb(int id, mm_sound_focus_type_e focus_type,
+ mm_sound_focus_state_e focus_state, const char *reason_for_change,
+ const char *additional_info, void *user_data);
+
#if 0
int mmradio_set_attrs(mm_radio_t* radio, MMRadioAttrsType type, MMHandleType attrs);
MMHandleType mmradio_get_attrs(mm_radio_t* radio, MMRadioAttrsType type);
+++ /dev/null
-/*
- * libmm-radio
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * 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.
- *
- */
-
-#include <assert.h>
-#include <mm_debug.h>
-#include "mm_radio_asm.h"
-#include "mm_radio_utils.h"
-
-int mmradio_asm_register(MMRadioASM* sm, ASM_sound_cb_t callback, void* param)
-{
- /* 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_MEDIA_FMRADIO;
- int pid = -1;
-
- MMRADIO_LOG_FENTER();
-
- if ( ! sm )
- {
- MMRADIO_LOG_ERROR("invalid session handle\n");
- return MM_ERROR_RADIO_NOT_INITIALIZED;
- }
-
- /* read session information */
- errorcode = _mm_session_util_read_information(pid, &session_type, &session_options);
- if ( errorcode )
- {
- debug_warning("Read Session Information failed. use default \"media\" type\n");
- session_type = MM_SESSION_TYPE_MEDIA;
- }
-
- /* check if it's MEDIA type */
- if ( session_type != MM_SESSION_TYPE_MEDIA)
- {
- MMRADIO_LOG_DEBUG("session type is not MEDIA (%d)\n", session_type);
- return MM_ERROR_RADIO_INTERNAL;
- }
-
- /* check if it's running on the media_server */
- if ( sm->pid > 0 )
- {
- pid = sm->pid;
- MMRADIO_LOG_DEBUG("mm-radio is running on different process. Just faking pid to [%d]. :-p\n", pid);
- }
- else
- {
- MMRADIO_LOG_DEBUG("no pid has assigned. using default(current) context\n");
- }
-
- /* register audio-session-manager callback */
- if( ! ASM_register_sound(pid, &asm_handle, event_type, ASM_STATE_NONE, callback, (void*)param, ASM_RESOURCE_NONE, &errorcode))
- {
- 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;
- sm->state = ASM_STATE_NONE;
-
- MMRADIO_LOG_FLEAVE();
-
- return MM_ERROR_NONE;
-}
-
-int mmradio_asm_deregister(MMRadioASM* sm)
-{
- int event_type = ASM_EVENT_MEDIA_FMRADIO;
- int errorcode = 0;
-
- MMRADIO_LOG_FENTER();
-
- if ( ! sm )
- {
- MMRADIO_LOG_ERROR("invalid session handle\n");
- return MM_ERROR_RADIO_NOT_INITIALIZED;
- }
-
- if( ! ASM_unregister_sound( sm->handle, event_type, &errorcode) )
- {
- MMRADIO_LOG_ERROR("Unregister sound failed 0x%X\n", errorcode);
- return MM_ERROR_POLICY_INTERNAL;
- }
-
- MMRADIO_LOG_FLEAVE();
-
- return MM_ERROR_NONE;
-}
-
-int mmradio_asm_set_state(MMRadioASM* sm, ASM_sound_states_t state, ASM_resource_t resource)
-{
- int event_type = ASM_EVENT_MEDIA_FMRADIO;
-
- MMRADIO_LOG_FENTER();
-
- if ( ! sm )
- {
- MMRADIO_LOG_ERROR("invalid session handle\n");
- return MM_ERROR_RADIO_NOT_INITIALIZED;
- }
-
- if ( sm->by_asm_cb == MMRADIO_ASM_CB_NONE ) //|| sm->state == ASM_STATE_PLAYING )
- {
- int ret = 0;
-
- 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);
- return MM_ERROR_POLICY_BLOCKED;
- }
-
- sm->state = state;
- }
- else // by asm callback
- {
- sm->by_asm_cb = MMRADIO_ASM_CB_NONE;
- sm->state = state;
- }
-
- MMRADIO_LOG_FLEAVE();
-
- return MM_ERROR_NONE;
-}
-
--- /dev/null
+/*
+ * libmm-radio
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * 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.
+ *
+ */
+
+#include <assert.h>
+#include <mm_debug.h>
+#include "mm_radio_audio_focus.h"
+#include "mm_radio_utils.h"
+#include "mm_sound_focus.h"
+#include "unistd.h"
+
+int mmradio_audio_focus_register(MMRadioAudioFocus* sm, mm_sound_focus_changed_cb callback, void* param)
+{
+ /* read mm-session information */
+ int session_type = MM_SESSION_TYPE_MEDIA;
+ int session_flags = 0;
+ int errorcode = MM_ERROR_NONE;
+ int pid = getpid();
+ int handle;
+
+ MMRADIO_LOG_FENTER();
+
+ if ( ! sm )
+ {
+ MMRADIO_LOG_ERROR("invalid session handle\n");
+ return MM_ERROR_RADIO_NOT_INITIALIZED;
+ }
+
+ /* read session information */
+ errorcode = _mm_session_util_read_information(pid, &session_type, &session_flags);
+ if ( errorcode == MM_ERROR_NONE )
+ {
+ debug_warning("Read Session Information success. session_type : %d flags: %d \n", session_type, session_flags);
+ sm->sound_focus_register = true;
+ sm->asm_session_flags = session_flags;
+ session_type = MM_SESSION_TYPE_MEDIA;
+ }
+ else
+ {
+ debug_warning("Read Session Information failed. skip sound focus function. errorcode %x \n" ,errorcode);
+ sm->sound_focus_register = false;
+ }
+
+ /* check if it's MEDIA type */
+ if ( session_type != MM_SESSION_TYPE_MEDIA)
+ {
+ MMRADIO_LOG_DEBUG("session type is not MEDIA (%d)\n", session_type);
+ return MM_ERROR_RADIO_INTERNAL;
+ }
+
+ /* check if it's running on the media_server */
+ if ( pid > 0 )
+ sm->pid = pid;
+ else
+ return MM_ERROR_INVALID_ARGUMENT;
+
+ MMRADIO_LOG_DEBUG("sound register focus pid[%d]", pid);
+
+ mm_sound_focus_get_id(&handle);
+ sm->handle = handle;
+ if(sm->sound_focus_register)
+ {
+ if(mm_sound_register_focus_for_session(handle, pid, "radio", callback, param) != MM_ERROR_NONE)
+ {
+ MMRADIO_LOG_DEBUG("mm_sound_register_focus_for_session is failed\n");
+ return MM_ERROR_POLICY_BLOCKED;
+ }
+ else
+ MMRADIO_LOG_DEBUG("mm_sound_register_focus_for_session is success. handle : %d session_type : %d, flags : %x\n", handle, session_type, sm->asm_session_flags);
+ }
+
+ MMRADIO_LOG_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
+
+
+int mmradio_audio_focus_deregister(MMRadioAudioFocus* sm)
+{
+ MMRADIO_LOG_FENTER();
+
+ if ( ! sm )
+ {
+ MMRADIO_LOG_ERROR("invalid session handle\n");
+ return MM_ERROR_RADIO_NOT_INITIALIZED;
+ }
+
+ if(sm->sound_focus_register)
+ {
+ if (MM_ERROR_NONE != mm_sound_unregister_focus(sm->handle))
+ MMRADIO_LOG_ERROR("mm_sound_unregister_focus failed\n");
+ }
+
+ MMRADIO_LOG_FLEAVE();
+
+ return MM_ERROR_NONE;
+}
+
+int mmradio_set_audio_focus(MMRadioAudioFocus* sm, mm_sound_focus_changed_watch_cb callback, void* param)
+{
+ int ret = MM_ERROR_NONE;
+ MMRADIO_LOG_FENTER();
+
+ MMRADIO_LOG_ERROR("mmradio_set_audio_focus asm_session_flags : %d\n", sm->asm_session_flags);
+ if(sm->asm_session_flags & MM_SESSION_OPTION_PAUSE_OTHERS)
+ {
+ ret = mm_sound_acquire_focus(sm->handle, FOCUS_FOR_BOTH, NULL);
+ if(ret != MM_ERROR_NONE)
+ {
+ MMRADIO_LOG_ERROR("mm_sound_set_audio_focus failed\n");
+ return MM_ERROR_POLICY_BLOCKED;
+ }
+ }
+ else
+ {
+ ret = mm_sound_set_focus_watch_callback_for_session(sm->pid, FOCUS_FOR_BOTH, callback, param, &sm->handle);
+ if(ret != MM_ERROR_NONE)
+ {
+ MMRADIO_LOG_ERROR("mm_sound_set_audio_focus failed\n");
+ return MM_ERROR_POLICY_BLOCKED;
+ }
+
+ MMRADIO_LOG_ERROR("mmradio_set_audio_focus ret: %d\n", ret);
+ }
+
+ MMRADIO_LOG_FLEAVE();
+ return ret ;
+}
+
+int mmradio_unset_audio_focus(MMRadioAudioFocus* sm, void* param)
+{
+ int ret = MM_ERROR_NONE;
+ MMRADIO_LOG_FENTER();
+
+ MMRADIO_LOG_ERROR("mmradio_set_audio_focus asm_session_flags : %d\n", sm->asm_session_flags);
+ if(sm->asm_session_flags & MM_SESSION_OPTION_PAUSE_OTHERS)
+ {
+ ret = mm_sound_release_focus(sm->handle, FOCUS_FOR_BOTH, NULL);
+ if(ret != MM_ERROR_NONE)
+ {
+ MMRADIO_LOG_ERROR("mmradio_unset_audio_focus failed\n");
+ return MM_ERROR_POLICY_BLOCKED;
+ }
+ }
+ else
+ {
+ ret = mm_sound_unset_focus_watch_callback(sm->handle);
+ if(ret != MM_ERROR_NONE)
+ {
+ MMRADIO_LOG_ERROR("mmradio_unset_audio_focus failed\n");
+ return MM_ERROR_POLICY_BLOCKED;
+ }
+
+ MMRADIO_LOG_ERROR("mmradio_unset_audio_focus ret: %d\n", ret);
+ }
+
+ MMRADIO_LOG_FLEAVE();
+ return ret ;
+}
+
+#define AUDIO_FOCUS_REASON_MAX 128
+
+void mmradio_get_audio_focus_reason(mm_sound_focus_state_e focus_state, const char *reason_for_change, ASM_event_sources_t *event_source, int *postMsg)
+{
+ MMRADIO_LOG_FENTER();
+ MMRADIO_LOG_ERROR("mmradio_get_audio_focus_reason focus_state : %d reason_for_change :%s\n", 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))
+ || (0 == strncmp(reason_for_change, "ringtone-voip", AUDIO_FOCUS_REASON_MAX))
+ || (0 == strncmp(reason_for_change, "ringtone-call", AUDIO_FOCUS_REASON_MAX))
+ )
+ {
+ if(focus_state == FOCUS_IS_RELEASED)
+ *event_source = ASM_EVENT_SOURCE_CALL_START;
+ else if(focus_state == FOCUS_IS_ACQUIRED)
+ *event_source = ASM_EVENT_SOURCE_CALL_END;
+ *postMsg = true;
+ }
+ else if(0 == strncmp(reason_for_change, "alarm", AUDIO_FOCUS_REASON_MAX))
+ {
+ if(focus_state == FOCUS_IS_RELEASED)
+ *event_source = ASM_EVENT_SOURCE_ALARM_START;
+ else if(focus_state == FOCUS_IS_ACQUIRED)
+ *event_source = ASM_EVENT_SOURCE_ALARM_END;
+ *postMsg = true;
+ }
+ else if(0 == strncmp(reason_for_change, "notification", AUDIO_FOCUS_REASON_MAX))
+ {
+ if(focus_state == FOCUS_IS_RELEASED)
+ *event_source = ASM_EVENT_SOURCE_NOTIFY_START;
+ else if(focus_state == FOCUS_IS_ACQUIRED)
+ *event_source = ASM_EVENT_SOURCE_NOTIFY_END;
+ *postMsg = true;
+ }
+ else if(0 == strncmp(reason_for_change, "emergency", AUDIO_FOCUS_REASON_MAX))
+ {
+ if(focus_state == FOCUS_IS_RELEASED)
+ *event_source = ASM_EVENT_SOURCE_EMERGENCY_START;
+ else if(focus_state == FOCUS_IS_ACQUIRED)
+ *event_source = ASM_EVENT_SOURCE_EMERGENCY_END;
+ *postMsg = false;
+ }
+ else if(0 == strncmp(reason_for_change, "media", AUDIO_FOCUS_REASON_MAX))
+ {
+ *event_source = ASM_EVENT_SOURCE_MEDIA;
+ *postMsg = false;
+ }
+ else
+ {
+ *event_source = ASM_EVENT_SOURCE_MEDIA;
+ *postMsg = false;
+ }
+ MMRADIO_LOG_FLEAVE();
+}
#include <sys/ioctl.h>
#include <unistd.h>
#include <errno.h>
-#include <mm_sound.h>
#include <mm_error.h>
#include <mm_debug.h>
#include <mm_message.h>
+
#include "mm_radio_priv.h"
/*===========================================================================================
static bool __mmradio_set_state(mm_radio_t* radio, int new_state);
static void __mmradio_seek_thread(mm_radio_t* radio);
static void __mmradio_scan_thread(mm_radio_t* radio);
-ASM_cb_result_t __mmradio_asm_callback(int handle, ASM_event_sources_t sound_event, ASM_sound_commands_t command, unsigned int sound_status, void* cb_data);
static bool __is_tunable_frequency(mm_radio_t* radio, int freq);
static int __mmradio_set_deemphasis(mm_radio_t* radio);
static int __mmradio_set_band_range(mm_radio_t* radio);
MMRADIO_SET_STATE( radio, MM_RADIO_STATE_NULL );
- /* register to ASM */
- ret = mmradio_asm_register(&radio->sm, __mmradio_asm_callback, (void*)radio);
+ /* register to audio focus */
+ ret = mmradio_audio_focus_register(&radio->sm, _mmradio_sound_focus_cb, (void *)radio);
if ( ret )
{
/* NOTE : we are dealing it as an error since we cannot expect it's behavior */
- MMRADIO_LOG_ERROR("failed to register asm server\n");
+ MMRADIO_LOG_ERROR("failed to register audio focus\n");
return MM_ERROR_RADIO_INTERNAL;
}
}
MMRADIO_SET_STATE( radio, MM_RADIO_STATE_NULL );
+
+ ret = mmradio_unset_audio_focus(&radio->sm, (void *)radio);
+ if (ret) {
+ MMRADIO_LOG_ERROR("failed to unset audio focus\n");
+ return ret;
+ }
#ifdef USE_GST_PIPELINE
ret= _mmradio_destroy_pipeline(radio);
if ( ret ) {
MMRADIO_CHECK_INSTANCE( radio );
MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_DESTROY );
- ret = mmradio_asm_deregister(&radio->sm);
+ ret = mmradio_audio_focus_deregister(&radio->sm);
if ( ret )
{
- MMRADIO_LOG_ERROR("failed to deregister asm server\n");
+ MMRADIO_LOG_ERROR("failed to deregister audio focus\n");
return MM_ERROR_RADIO_INTERNAL;
}
MMRADIO_LOG_DEBUG("now tune to frequency : %d\n", radio->freq);
- ret = mmradio_asm_set_state(&radio->sm, ASM_STATE_PLAYING, ASM_RESOURCE_RADIO_TUNNER);
+ ret = mmradio_set_audio_focus(&radio->sm, _mmradio_sound_focus_watch_cb, (void *)radio);
if ( ret )
{
- MMRADIO_LOG_ERROR("failed to set asm state to PLAYING\n");
+ MMRADIO_LOG_ERROR("failed to set audio focus\n");
return ret;
}
MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
- ret = mmradio_asm_set_state(&radio->sm, ASM_STATE_STOP, ASM_RESOURCE_NONE);
- if ( ret )
- {
- MMRADIO_LOG_ERROR("failed to set asm state to PLAYING\n");
- return ret;
- }
#ifdef USE_GST_PIPELINE
ret= _mmradio_stop_pipeline( radio );
if ( ret ) {
vs.seek_upward = 1; /* up : 1 ------- down : 0 */
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE_RETURN_VOID( radio );
if( _mmradio_mute(radio) != MM_ERROR_NONE)
goto FINISHED;
vs.wrap_around = DEFAULT_WRAP_AROUND;
MMRADIO_LOG_FENTER();
- MMRADIO_CHECK_INSTANCE( radio );
+ MMRADIO_CHECK_INSTANCE_RETURN_VOID( radio );
/* check direction */
switch( radio->seek_direction )
return radio->current_state;
}
-ASM_cb_result_t
-__mmradio_asm_callback(int handle, ASM_event_sources_t event_source, ASM_sound_commands_t command, unsigned int sound_status, void* cb_data)
+void _mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
+ mm_sound_focus_state_e focus_state, const char *reason_for_change,
+ const char *additional_info, void *user_data)
{
- mm_radio_t* radio = (mm_radio_t*) cb_data;
+ mm_radio_t *radio = (mm_radio_t *) user_data;
+ ASM_event_sources_t event_source;
int result = MM_ERROR_NONE;
- ASM_cb_result_t cb_res = ASM_CB_RES_NONE;
+ int postMsg = false;
MMRADIO_LOG_FENTER();
+ MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
+ mmradio_get_audio_focus_reason(focus_state, reason_for_change, &event_source, &postMsg);
radio->sm.event_src = event_source;
- switch(command)
- {
- case ASM_COMMAND_STOP:
- case ASM_COMMAND_PAUSE:
- {
- MMRADIO_LOG_DEBUG("ASM asked me to stop. cmd : %d\n", command);
- switch(event_source)
- {
- case ASM_EVENT_SOURCE_CALL_START:
- case ASM_EVENT_SOURCE_ALARM_START:
- case ASM_EVENT_SOURCE_EARJACK_UNPLUG:
- case ASM_EVENT_SOURCE_MEDIA:
- {
- radio->sm.by_asm_cb = MMRADIO_ASM_CB_POSTMSG;
- result = _mmradio_stop(radio);
- if( result )
- {
- MMRADIO_LOG_ERROR("failed to stop radio\n");
- }
-
- MMRADIO_LOG_DEBUG("skip unrealize in asm callback");
- }
- break;
-
- case ASM_EVENT_SOURCE_RESOURCE_CONFLICT:
- default:
- {
- radio->sm.by_asm_cb = MMRADIO_ASM_CB_POSTMSG;
- result = _mmradio_stop(radio);
- if( result )
- {
- MMRADIO_LOG_ERROR("failed to stop radio\n");
- }
- }
- break;
+ switch (focus_state) {
+ case FOCUS_IS_RELEASED:
+ radio->sm.by_asm_cb = MMRADIO_ASM_CB_POSTMSG;
+ result = _mmradio_stop(radio);
+ if (result) {
+ MMRADIO_LOG_ERROR("failed to stop radio\n");
}
- cb_res = ASM_CB_RES_STOP;
- }
- break;
+ MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED\n");
+ break;
- case ASM_COMMAND_PLAY:
- case ASM_COMMAND_RESUME:
- {
- MMMessageParamType msg = {0,};
- msg.union_type = MM_MSG_UNION_CODE;
- msg.code = event_source;
+ case FOCUS_IS_ACQUIRED: {
+ MMMessageParamType msg = {0,};
+ msg.union_type = MM_MSG_UNION_CODE;
+ msg.code = event_source;
+ if (postMsg)
+ MMRADIO_POST_MSG(radio, MM_MESSAGE_READY_TO_RESUME, &msg);
- MMRADIO_LOG_DEBUG("Got ASM resume message by %d\n", msg.code);
- MMRADIO_POST_MSG(radio, MM_MESSAGE_READY_TO_RESUME, &msg);
+ radio->sm.by_asm_cb = MMRADIO_ASM_CB_NONE;
- cb_res = ASM_CB_RES_IGNORE;
- radio->sm.by_asm_cb = MMRADIO_ASM_CB_NONE;
- }
- break;
+ MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED\n");
+ }
+ break;
default:
- break;
+ MMRADIO_LOG_DEBUG("Unknown focus_state\n");
+ break;
}
-
MMRADIO_LOG_FLEAVE();
+}
+
+void _mmradio_sound_focus_watch_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e focus_state,
+ const char *reason_for_change, const char *additional_info, void *user_data)
+{
+ mm_radio_t *radio = (mm_radio_t *) user_data;
+ ASM_event_sources_t event_source;
+ int result = MM_ERROR_NONE;
+ int postMsg = false;
+
+ MMRADIO_LOG_FENTER();
+ MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
+
+ mmradio_get_audio_focus_reason(!focus_state, reason_for_change, &event_source, &postMsg);
+ radio->sm.event_src = event_source;
+
+ switch (focus_state) {
+ case FOCUS_IS_RELEASED: {
+ MMMessageParamType msg = {0,};
+ msg.union_type = MM_MSG_UNION_CODE;
+ msg.code = event_source;
+ if (postMsg)
+ MMRADIO_POST_MSG(radio, MM_MESSAGE_READY_TO_RESUME, &msg);
- return cb_res;
+ radio->sm.by_asm_cb = MMRADIO_ASM_CB_NONE;
+
+ MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED postMsg: %d\n", postMsg);
+ }
+ break;
+
+ case FOCUS_IS_ACQUIRED: {
+ radio->sm.by_asm_cb = MMRADIO_ASM_CB_POSTMSG;
+ result = _mmradio_stop(radio);
+ if (result) {
+ MMRADIO_LOG_ERROR("failed to stop radio\n");
+ }
+ MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED\n");
+ break;
+ }
+ break;
+
+ default:
+ MMRADIO_LOG_DEBUG("Unknown focus_state postMsg : %d\n", postMsg);
+ break;
+ }
+ MMRADIO_LOG_FLEAVE();
}
int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type)
projects / platform / core / multimedia / libmm-radio.git / commitdiff