path: root/mm_sound.c

/*
 * libmm-sound
 *
 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact: Seungbae Shin <seungbae.shin@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 <stdlib.h>
#include <memory.h>
#include <unistd.h>
#include <pthread.h>

#include <errno.h>

#include <vconf.h>
#include <mm_types.h>
#include <mm_error.h>
#include <mm_debug.h>
#include "include/mm_sound_private.h"
#include "include/mm_sound_utils.h"
#include "include/mm_sound_client.h"
#include "include/mm_sound_pa_client.h"
#include "include/mm_sound_common.h"

#define MASTER_VOLUME_MAX 100
#define MASTER_VOLUME_MIN 0

#include <gio/gio.h>

#define MM_SOUND_DBUS_BUS_NAME_PREPIX  "org.tizen.MMSound"
#define MM_SOUND_DBUS_OBJECT_PATH  "/org/tizen/MMSound"
#define MM_SOUND_DBUS_INTERFACE    "org.tizen.mmsound"

static const char* _get_volume_str(volume_type_t type)
{
	static const char *volume_type_str[VOLUME_TYPE_MAX] = {
		"SYSTEM", "NOTIFICATION", "ALARM", "RINGTONE", "MEDIA", "CALL", "VOIP", "VOICE", "FIXED"
	};

	return (type < VOLUME_TYPE_MAX) ? volume_type_str[type] : "Unknown";
}

static const char* _get_volume_str_internal(volume_type_internal_t type)
{
	static const char *volume_type_str[] = {
		"BIXBY"
	};

	return (type < (VOLUME_TYPE_BIXBY + 1)) ? volume_type_str[type] : "Unknown";
}

EXPORT_API
int mm_sound_add_volume_changed_callback(mm_sound_volume_changed_cb func, void* user_data, unsigned int *subs_id)
{
	int ret = MM_ERROR_NONE;

	if (func == NULL || subs_id == NULL) {
		debug_error("argument is not valid");
		return MM_ERROR_INVALID_ARGUMENT;
	}

	ret = mm_sound_client_add_volume_changed_callback(func, user_data, subs_id);
	if (ret < 0) {
		debug_error("Can not add volume changed callback, ret = %x", ret);
	}

	return ret;
}

EXPORT_API
int mm_sound_remove_volume_changed_callback(unsigned int subs_id)
{
	int ret = MM_ERROR_NONE;

	ret = mm_sound_client_remove_volume_changed_callback(subs_id);
	if (ret < 0) {
		debug_error("Can not remove volume changed callback, ret = %x", ret);
	}

	return ret;
}

EXPORT_API
int mm_sound_volume_set_value(volume_type_t type, const unsigned int value)
{
	int ret = MM_ERROR_NONE;

	/* request daemon to set volume */
	ret = mm_sound_client_set_volume_by_type(type, value);
	if (ret)
		debug_error("can not set volume, type(%s), value(%d), ret=0x%x", _get_volume_str(type), value, ret);
	else
		debug_msg("set (%s) volume to (%d)",  _get_volume_str(type), value);

	return ret;
}

EXPORT_API
int mm_sound_volume_get_value(volume_type_t type, unsigned int *value)
{
	int ret = MM_ERROR_NONE;

	ret = mm_sound_client_get_volume_by_type(type, value);
	if (ret)
		debug_error("can not get volume, type(%s), ret=0x%x", _get_volume_str(type), ret);
	else
		debug_msg("(%s) volume : %d",  _get_volume_str(type), *value);

	return ret;
}

EXPORT_API
int mm_sound_add_volume_changed_callback_internal(mm_sound_volume_changed_cb_internal func, void* user_data, unsigned int *subs_id)
{
	int ret = MM_ERROR_NONE;

	if (func == NULL || subs_id == NULL) {
		debug_error("argument is not valid");
		return MM_ERROR_INVALID_ARGUMENT;
	}

	ret = mm_sound_client_add_volume_changed_callback_internal(func, user_data, subs_id);
	if (ret < 0)
		debug_error("Can not add internal volume changed callback, ret = %x", ret);

	return ret;
}

EXPORT_API
int mm_sound_remove_volume_changed_callback_internal(unsigned int subs_id)
{
	int ret = MM_ERROR_NONE;

	ret = mm_sound_client_remove_volume_changed_callback(subs_id);
	if (ret < 0)
		debug_error("Can not remove internal volume changed callback, ret = %x", ret);

	return ret;
}

EXPORT_API
int mm_sound_volume_set_value_internal(volume_type_internal_t type, const unsigned int value)
{
	int ret = MM_ERROR_NONE;

	/* request daemon to set volume */
	ret = mm_sound_client_set_volume_by_internal_type(type, value);
	if (ret)
		debug_error("can not set internal volume, type(%s), value(%d), ret=0x%x", _get_volume_str_internal(type), value, ret);
	else
		debug_msg("set (%s) volume to (%d)",  _get_volume_str_internal(type), value);

	return ret;
}

EXPORT_API
int mm_sound_volume_get_value_internal(volume_type_internal_t type, unsigned int *value)
{
	int ret = MM_ERROR_NONE;

	ret = mm_sound_client_get_volume_by_internal_type(type, value);
	if (ret)
		debug_error("can not get internal volume, type(%s), ret=0x%x", _get_volume_str_internal(type), ret);
	else
		debug_msg("(%s) volume : %d",  _get_volume_str_internal(type), *value);

	return ret;
}

EXPORT_API
int mm_sound_set_mute(volume_type_t type, bool mute)
{
	int ret = MM_ERROR_NONE;

	ret = mm_sound_client_set_mute_by_type(type, mute);
	if (ret)
		debug_error("can not set mute, type(%s), mute(%d), ret=0x%x", _get_volume_str(type), mute, ret);
	else
		debug_msg("set (%s) mute to (%d)",  _get_volume_str(type), mute);

	return ret;
}

EXPORT_API
int mm_sound_get_mute(volume_type_t type, bool  *muted)
{
	int ret = MM_ERROR_NONE;

	/* Check input param */
	if (!muted) {
		debug_error("invalid argument");
		return MM_ERROR_INVALID_ARGUMENT;
	}
	if (type > VOLUME_TYPE_VOICE) {
		debug_error("invalid volume type value %d", type);
		return MM_ERROR_INVALID_ARGUMENT;
	}

	ret = mm_sound_client_get_mute_by_type(type, muted);
	if (ret)
		debug_error("can not get mute, type(%s), ret=0x%x", _get_volume_str(type), ret);
	else
		debug_msg("(%s) mute state : %d",  _get_volume_str(type), *muted);

	return ret;
}

EXPORT_API
int mm_sound_set_filter(const char *stream_type, const char *filter_name, const char *filter_parameters, const char *filter_group)
{
	/* Check input param */
	if (!stream_type || !filter_name) {
		debug_error("invalid argument");
		return MM_ERROR_INVALID_ARGUMENT;
	}
	if (!filter_parameters)
		filter_parameters = "";
	if (!filter_group)
		filter_group = "default";

	debug_msg("stream_type(%s), filter_name(%s), filter_parameters(%s), filter_group(%s)", stream_type, filter_name, filter_parameters, filter_group);

	return mm_sound_client_set_filter_by_type(stream_type, filter_name, filter_parameters, filter_group);
}

EXPORT_API
int mm_sound_unset_filter(const char *stream_type)
{
	/* Check input param */
	if (!stream_type) {
		debug_error("invalid argument");
		return MM_ERROR_INVALID_ARGUMENT;
	}

	debug_msg("stream_type(%s)", stream_type);

	return mm_sound_client_unset_filter_by_type(stream_type);
}

EXPORT_API
int mm_sound_control_filter(const char *stream_type, const char *filter_name, const char *filter_controls)
{
	/* Check input param */
	if (!stream_type || !filter_name || !filter_controls) {
		debug_error("invalid argument");
		return MM_ERROR_INVALID_ARGUMENT;
	}

	debug_msg("stream_type(%s), filter_name(%s), filter_controls(%s)", stream_type, filter_name, filter_controls);

	return mm_sound_client_control_filter_by_type(stream_type, filter_name, filter_controls);
}

///////////////////////////////////
////     MMSOUND ROUTING APIs
///////////////////////////////////

EXPORT_API
int mm_sound_add_ducking_state_changed_callback(mm_sound_ducking_state_changed_cb func, void *user_data, unsigned int *subs_id)
{
	int ret = MM_ERROR_NONE;

	if (func == NULL || subs_id == NULL) {
		debug_error("argument is not valid");
		return MM_ERROR_INVALID_ARGUMENT;
	}

	ret = mm_sound_client_add_ducking_state_changed_callback(func, user_data, subs_id);
	if (ret < 0) {
		debug_error("Can not add ducking state changed callback, ret = %x", ret);
	}

	return ret;
}

EXPORT_API
int mm_sound_remove_ducking_state_changed_callback(unsigned int subs_id)
{
	int ret = MM_ERROR_NONE;

	ret = mm_sound_client_remove_ducking_state_changed_callback(subs_id);
	if (ret < 0) {
		debug_error("Can not remove ducking state changed callback, ret = %x", ret);
	}

	return ret;
}

#ifdef TIZEN_TV
EXPORT_API
void mm_sound_dotnet_cleanup(int signo)
{
}
#endif

__attribute__ ((constructor))
static void _mm_sound_initialize(void)
{
	mm_sound_client_initialize();
	/* Will be Fixed */
}

__attribute__ ((destructor))
static void _mm_sound_finalize(void)
{
	mm_sound_client_finalize();
}