path: root/src/mm_radio_sound_focus.c

/*
 * mm_radio_sound_focus.c
 *
 * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * 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 <unistd.h>
#include <mm_debug.h>
#include <mm_sound.h>
#include <mm_sound_focus.h>
#include <mm_sound_device.h>
#include "mm_radio_utils.h"
#include "mm_radio_priv_hal.h"
#include "mm_radio_sound_focus.h"

static void _mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connected, void *user_data)
{
	mm_radio_t *radio = (mm_radio_t *)user_data;
	int result = MM_ERROR_NONE;
	mm_sound_device_type_e type;

	MMRADIO_LOG_FENTER();
	MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);

	if (mm_sound_get_device_type(device, &type) != MM_ERROR_NONE) {
		MMRADIO_LOG_ERROR("getting device type failed");
	} else {
		switch (type) {
		case MM_SOUND_DEVICE_TYPE_AUDIOJACK:
		case MM_SOUND_DEVICE_TYPE_BLUETOOTH:
		case MM_SOUND_DEVICE_TYPE_HDMI:
		case MM_SOUND_DEVICE_TYPE_MIRRORING:
		case MM_SOUND_DEVICE_TYPE_USB_AUDIO:
			if (!is_connected) {
				MMRADIO_LOG_ERROR("sound device unplugged");
				radio->sound_focus.by_focus_cb = MMRADIO_FOCUS_CB_POSTMSG;
				radio->sound_focus.event_src = MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG;

				result = _mmradio_stop(radio);
				if (result != MM_ERROR_NONE)
					MMRADIO_LOG_ERROR("failed to stop radio\n");
			}
			break;
		default:
			break;
		}
	}
	MMRADIO_LOG_FLEAVE();
}

void _mmradio_sound_signal_callback(mm_sound_signal_name_t signal, int value, void *user_data)
{
	mm_radio_sound_focus *sound_focus = (mm_radio_sound_focus *)user_data;
	int ret = MM_ERROR_NONE;

	MMRADIO_LOG_DEBUG("sound signal callback %d / %d", signal, value);

	if (signal == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) {
		if (value == 1) {
			/* unregister watch callback */
			if (sound_focus->watch_id > 0) {
				MMRADIO_LOG_DEBUG("unset the focus watch cb %d", sound_focus->watch_id);

				ret = mm_sound_unset_focus_watch_callback(sound_focus->watch_id);
				sound_focus->watch_id = 0;
				if (ret != MM_ERROR_NONE)
					MMRADIO_LOG_ERROR("failed to mm_sound_unset_focus_watch_callback()");
			}
			/* unregister focus callback */
			if (sound_focus->focus_id > 0) {
				ret = mm_sound_unregister_focus(sound_focus->focus_id);
				sound_focus->focus_id = 0;
				if (ret != MM_ERROR_NONE)
					MMRADIO_LOG_ERROR("failed to mm_sound_unregister_focus() %d", sound_focus->focus_id);
			}
			/* unregister device connected callback */
			if (sound_focus->device_subs_id > 0) {
				MMRADIO_LOG_DEBUG("unset the device connected cb %d", sound_focus->device_subs_id);
				ret = mm_sound_remove_device_connected_callback(sound_focus->device_subs_id);
				sound_focus->device_subs_id = 0;
				if (ret != MM_ERROR_NONE)
					MMRADIO_LOG_ERROR("failed to mm_sound_remove_device_connected_callback()");
			}
		}
	}
}

int mmradio_sound_focus_register(mm_radio_sound_focus *sound_focus,
	mm_sound_focus_changed_cb focus_cb, mm_sound_focus_changed_watch_cb watch_cb, void *param)
{
	/* read mm-session information */
	int session_type = MM_SESSION_TYPE_MEDIA;
	int session_flags = 0;
	int ret = MM_ERROR_NONE;
	int pid = getpid();
	int handle = 0;

	MMRADIO_LOG_FENTER();

	if (!sound_focus) {
		MMRADIO_LOG_ERROR("invalid session handle\n");
		return MM_ERROR_RADIO_NOT_INITIALIZED;
	}
	sound_focus->cur_focus_type = FOCUS_NONE;

	/* read session information */
	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);
		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");
				return MM_ERROR_POLICY_BLOCKED;
			}
			MMRADIO_LOG_DEBUG("register focus watch callback for the value is 0, sub_cb id %d\n", 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");
				return MM_ERROR_POLICY_BLOCKED;
			}
			MMRADIO_LOG_DEBUG("(%p) set focus watch callback = %d", param, sound_focus->watch_id);

			/* register device connected callback */
			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");
				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);
		}
		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);
		sound_focus->session_type = session_type;
		sound_focus->snd_session_flags = session_flags;
		if (sound_focus->session_type == MM_SESSION_TYPE_MEDIA) {
			if (sound_focus->snd_session_flags & MM_SESSION_OPTION_PAUSE_OTHERS) {
				/* register focus session */
				sound_focus->pid = pid;
				MMRADIO_LOG_DEBUG("sound register focus pid[%d]", pid);
				ret = mm_sound_focus_get_id(&handle);
				if (ret != MM_ERROR_NONE) {
					MMRADIO_LOG_ERROR("Failed to get sound focus id");
					return MM_ERROR_POLICY_BLOCKED;
				}
				sound_focus->handle = handle;

				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");
					return MM_ERROR_POLICY_BLOCKED;
				}
				MMRADIO_LOG_DEBUG("(%p) register focus for session %d", param, pid);
				/* register device_connected_cb */
				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");
					return MM_ERROR_POLICY_BLOCKED;
				}
				MMRADIO_LOG_DEBUG("(%p) add device connected callback = %d", param, sound_focus->device_subs_id);

			} else if (sound_focus->snd_session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
				/* register device_connected_cb */
				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");
					return MM_ERROR_POLICY_BLOCKED;
				}
				MMRADIO_LOG_DEBUG("add device connected callback = %d", sound_focus->device_subs_id);
				MMRADIO_LOG_WARNING("settion flags isn't OPTION_PAUSE_OTHERS and UNINTERRUPTIBLE. skip it..");
			} else {
				/* 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");
					return MM_ERROR_POLICY_BLOCKED;
				}
				MMRADIO_LOG_DEBUG("set focus watch callback = %d", sound_focus->watch_id);

				/* register device connected callback */
				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");
					return MM_ERROR_POLICY_BLOCKED;
				}
				MMRADIO_LOG_DEBUG("(%p) add device connected callback = %d", param, sound_focus->device_subs_id);
			}
		} else if (sound_focus->session_type == MM_SESSION_TYPE_REPLACED_BY_STREAM) {
			/* didn't register device connected cb */
			MMRADIO_LOG_WARNING("this process is using stream info. skip it..");
		} else {
			MMRADIO_LOG_WARNING("seesion type is not MEDIA (%d)", sound_focus->session_type);
			return MM_ERROR_RADIO_INTERNAL;
		}
		ret = MM_ERROR_NONE;
	} else {
		MMRADIO_LOG_WARNING("Read Session Information failed. skip sound focus register function. errorcode %x \n", ret);
	}

	MMRADIO_LOG_FLEAVE();

	return MM_ERROR_NONE;
}

int mmradio_sound_focus_deregister(mm_radio_sound_focus *sound_focus)
{

	int ret = MM_ERROR_NONE;

	MMRADIO_LOG_FENTER();

	if (!sound_focus) {
		MMRADIO_LOG_ERROR("invalid session handle\n");
		return MM_ERROR_RADIO_NOT_INITIALIZED;
	}

	if (sound_focus->watch_id > 0) {
		MMRADIO_LOG_DEBUG("unset the focus watch cb %d", sound_focus->watch_id);

		ret = mm_sound_unset_focus_watch_callback(sound_focus->watch_id);
		sound_focus->watch_id = 0;
		if (ret != MM_ERROR_NONE)
			MMRADIO_LOG_ERROR("failed to mm_sound_unset_focus_watch_callback() ret = %d", ret);
	}
	/* unregister focus callback */
	if (sound_focus->focus_id > 0) {
		ret = mm_sound_unregister_focus(sound_focus->focus_id);
		sound_focus->focus_id = 0;
		if (ret != MM_ERROR_NONE)
			MMRADIO_LOG_ERROR("failed to mm_sound_unregister_focus() ret = %d", ret);
	}
	/* unregister device connected callback */
	if (sound_focus->device_subs_id > 0) {
		MMRADIO_LOG_DEBUG("unset the device connected cb %d", sound_focus->device_subs_id);
		ret = mm_sound_remove_device_connected_callback(sound_focus->device_subs_id);
		sound_focus->device_subs_id = 0;
		if (ret != MM_ERROR_NONE)
			MMRADIO_LOG_ERROR("failed to mm_sound_remove_device_connected_callback() ret = %d", ret);
	}

	MMRADIO_LOG_FLEAVE();

	return MM_ERROR_NONE;
}

int mmradio_acquire_sound_focus(mm_radio_sound_focus *sound_focus)
{
	int ret = MM_ERROR_NONE;
	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);

	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");
			return MM_ERROR_POLICY_BLOCKED;
		}
		sound_focus->cur_focus_type = FOCUS_FOR_BOTH;
	}

	MMRADIO_LOG_FLEAVE();
	return ret;
}

int mmradio_release_sound_focus(mm_radio_sound_focus *sound_focus)
{
	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);
	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");
			return MM_ERROR_POLICY_BLOCKED;
		}
		sound_focus->cur_focus_type = FOCUS_NONE;
	}

	MMRADIO_LOG_FLEAVE();
	return ret;
}

#define AUDIO_FOCUS_REASON_MAX	128

void mmradio_get_sound_focus_reason(mm_sound_focus_state_e focus_state, const char *reason_for_change, 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);

	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 = MM_MSG_CODE_INTERRUPTED_BY_CALL_START;
		else if (focus_state == FOCUS_IS_ACQUIRED)
			*event_source = MM_MSG_CODE_INTERRUPTED_BY_CALL_END;
		*postMsg = true;
	} else if (0 == strncmp(reason_for_change, "alarm", AUDIO_FOCUS_REASON_MAX)) {
		if (focus_state == FOCUS_IS_RELEASED)
			*event_source = MM_MSG_CODE_INTERRUPTED_BY_ALARM_START;
		else if (focus_state == FOCUS_IS_ACQUIRED)
			*event_source = MM_MSG_CODE_INTERRUPTED_BY_ALARM_END;
		*postMsg = true;
	} else if (0 == strncmp(reason_for_change, "notification", AUDIO_FOCUS_REASON_MAX)) {
		if (focus_state == FOCUS_IS_RELEASED)
			*event_source = MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_START;
		else if (focus_state == FOCUS_IS_ACQUIRED)
			*event_source = MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_END;
		*postMsg = true;
	} else if (0 == strncmp(reason_for_change, "emergency", AUDIO_FOCUS_REASON_MAX)) {
		if (focus_state == FOCUS_IS_RELEASED)
			*event_source = MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START;
		else if (focus_state == FOCUS_IS_ACQUIRED)
			*event_source = MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END;
		*postMsg = false;
	} else if (0 == strncmp(reason_for_change, "media", AUDIO_FOCUS_REASON_MAX)) {
		*event_source = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
		*postMsg = false;
	} else {
		*event_source = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
		*postMsg = false;
	}
	MMRADIO_LOG_FLEAVE();
}