--- /dev/null
+#!/bin/sh
+
+. ./config
+export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH
--- /dev/null
+#!/bin/sh
+. ./config
+export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path
+export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target
+export PATH=$TET_TARGET_PATH/bin:$PATH
+export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
+export TET_ROOT=$TET_TARGET_PATH
--- /dev/null
+#!/bin/sh
+
+. ./_export_env.sh # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -c -p ./
+tcc -b -j $JOURNAL_RESULT -p ./
+grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
--- /dev/null
+#!/bin/sh
+
+. ./_export_env.sh # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+RESULT_DIR=results
+
+tcc -c -p ./ # executing tcc, with clean option (-c)
+rm -r $RESULT_DIR
+rm -r tet_tmp_dir
+rm testcase/tet_captured
--- /dev/null
+CAPI_PROJECT_ROOT=/home/abyss/capi
+TET_INSTALL_HOST_PATH=/home/abyss/TETware
+TET_INSTALL_TARGET_PATH=/mnt/nfs/TETware
--- /dev/null
+#!/bin/sh
+
+. ./_export_target_env.sh # setting environment variables
+
+export TET_SUITE_ROOT=`pwd`
+FILE_NAME_EXTENSION=`date +%s`
+
+RESULT_DIR=results
+HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html
+JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal
+
+mkdir -p $RESULT_DIR
+
+tcc -e -j $JOURNAL_RESULT -p ./
+grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
--- /dev/null
+CC ?= gcc
+
+C_FILES = $(shell ls *.c)
+
+PKGS = capi-media-sound-manager dlog glib-2.0
+
+LDFLAGS = `pkg-config --libs $(PKGS)`
+LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s
+LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s
+
+CFLAGS = -I. `pkg-config --cflags $(PKGS)`
+CFLAGS += -I$(TET_ROOT)/inc/tet3
+CFLAGS += -Wall
+
+#TARGETS = $(C_FILES:%.c=tc-%)
+TCS := $(shell ls -1 *.c | cut -d. -f1)
+
+all: $(TCS)
+
+%: %.c
+ $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS)
+
+clean:
+ rm -f $(TCS)
--- /dev/null
+/testcase/utc_media_sound_manager
+/testcase/utc_media_sound_manager_callback
\ No newline at end of file
--- /dev/null
+/*
+* Copyright (c) 2011 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 <tet_api.h>
+#include <media/sound_manager.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_media_sound_manager_get_max_volume_p(void);
+static void utc_media_sound_manager_get_max_volume_n(void);
+static void utc_media_sound_manager_set_volume_p(void);
+static void utc_media_sound_manager_set_volume_n(void);
+static void utc_media_sound_manager_get_volume_p(void);
+static void utc_media_sound_manager_get_volume_n(void);
+static void utc_media_sound_manager_set_route_policy_p(void);
+static void utc_media_sound_manager_set_route_policy_n(void);
+static void utc_media_sound_manager_get_route_policy_p(void);
+static void utc_media_sound_manager_get_route_policy_n(void);
+static void utc_media_sound_manager_get_current_sound_type_p(void);
+static void utc_media_sound_manager_get_current_sound_type_n(void);
+static void utc_media_sound_manager_get_current_sound_device_p(void);
+static void utc_media_sound_manager_get_current_sound_device_n(void);
+static void utc_media_sound_manager_set_session_type_p(void);
+static void utc_media_sound_manager_set_session_type_n(void);
+static void utc_media_sound_manager_get_a2dp_status_p(void);
+static void utc_media_sound_manager_get_a2dp_status_n(void);
+
+static void utc_media_sound_manager_foreach_available_route_p(void);
+static void utc_media_sound_manager_foreach_available_route_n(void);
+static void utc_media_sound_manager_set_active_route_p(void);
+static void utc_media_sound_manager_set_active_route_n(void);
+static void utc_media_sound_manager_get_active_device_p(void);
+static void utc_media_sound_manager_get_active_device_n(void);
+static void utc_media_sound_manager_is_route_available_p(void);
+static void utc_media_sound_manager_is_route_available_n(void);
+
+static void utc_media_sound_manager_call_session_create_p(void);
+static void utc_media_sound_manager_call_session_create_n(void);
+static void utc_media_sound_manager_call_session_set_mode_p(void);
+static void utc_media_sound_manager_call_session_set_mode_n(void);
+static void utc_media_sound_manager_call_session_get_mode_p(void);
+static void utc_media_sound_manager_call_session_get_mode_n(void);
+static void utc_media_sound_manager_call_session_destroy_p(void);
+static void utc_media_sound_manager_call_session_destroy_n(void);
+
+struct tet_testlist tet_testlist[] = {
+ { utc_media_sound_manager_get_max_volume_p , 1 },
+ { utc_media_sound_manager_get_max_volume_n , 2 },
+ { utc_media_sound_manager_set_volume_p, 3 },
+ { utc_media_sound_manager_set_volume_n, 4 },
+ { utc_media_sound_manager_get_volume_p, 5 },
+ { utc_media_sound_manager_get_volume_n, 6 },
+ { utc_media_sound_manager_set_route_policy_p, 7 },
+ { utc_media_sound_manager_set_route_policy_n, 8 },
+ { utc_media_sound_manager_get_route_policy_p, 9 },
+ { utc_media_sound_manager_get_route_policy_n, 10 },
+ { utc_media_sound_manager_get_current_sound_type_p , 11 },
+ { utc_media_sound_manager_get_current_sound_type_n, 12 },
+ { utc_media_sound_manager_get_current_sound_device_p, 13 },
+ { utc_media_sound_manager_get_current_sound_device_n, 14 },
+ { utc_media_sound_manager_get_a2dp_status_p, 15 },
+ { utc_media_sound_manager_get_a2dp_status_n, 16 },
+ { utc_media_sound_manager_foreach_available_route_p, 17 },
+ { utc_media_sound_manager_foreach_available_route_n, 18 },
+ { utc_media_sound_manager_set_active_route_p, 19 },
+ { utc_media_sound_manager_set_active_route_n, 20 },
+ { utc_media_sound_manager_get_active_device_p, 21 },
+ { utc_media_sound_manager_get_active_device_n, 22 },
+ { utc_media_sound_manager_is_route_available_p, 23 },
+ { utc_media_sound_manager_is_route_available_n, 24 },
+ { utc_media_sound_manager_call_session_create_p, 25 },
+ { utc_media_sound_manager_call_session_create_n, 26 },
+ { utc_media_sound_manager_call_session_set_mode_p, 27 },
+ { utc_media_sound_manager_call_session_set_mode_n, 28 },
+ { utc_media_sound_manager_call_session_get_mode_p, 29 },
+ { utc_media_sound_manager_call_session_get_mode_n, 30 },
+ { utc_media_sound_manager_call_session_destroy_p, 31 },
+ { utc_media_sound_manager_call_session_destroy_n, 32 },
+ { utc_media_sound_manager_set_session_type_p, 33 },
+ { utc_media_sound_manager_set_session_type_n, 34 },
+ { NULL, 0 },
+};
+
+static void startup(void)
+{
+ /* start of TC */
+}
+
+static void cleanup(void)
+{
+ /* end of TC */
+}
+
+static void utc_media_sound_manager_get_max_volume_p(void)
+{
+ char* api_name = "sound_manager_get_max_volume";
+ int ret, max;
+ if ((ret = sound_manager_get_max_volume(SOUND_TYPE_SYSTEM, &max)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_max_volume_n(void)
+{
+ char* api_name = "sound_manager_get_max_volume";
+ int ret, max;
+ if ((ret = sound_manager_get_max_volume(-1, &max)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_set_volume_p(void)
+{
+ char* api_name = "sound_manager_set_volume";
+ int ret, max;
+ if ((ret = sound_manager_get_max_volume(SOUND_TYPE_SYSTEM, &max)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ if ((ret = sound_manager_set_volume(SOUND_TYPE_NOTIFICATION, max/2)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_set_volume_n(void)
+{
+ char* api_name = "sound_manager_set_volume";
+ int ret;
+ if ((ret = sound_manager_set_volume(-1, 10)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_volume_p(void)
+{
+ char* api_name = "sound_manager_get_volume";
+ int ret, vol;
+ if ((ret = sound_manager_get_volume(SOUND_TYPE_ALARM , &vol)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_volume_n(void)
+{
+ char* api_name = "sound_manager_get_volume";
+ int ret;
+ if ((ret = sound_manager_get_volume(SOUND_TYPE_ALARM , NULL)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_set_route_policy_p(void)
+{
+ char* api_name = "sound_manager_set_route_policy";
+ int ret;
+ if ((ret = sound_manager_set_route_policy(SOUND_ROUTE_IGNORE_A2DP)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_set_route_policy_n(void)
+{
+ char* api_name = "sound_manager_set_route_policy";
+ int ret;
+ if ((ret = sound_manager_set_route_policy(-1)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_route_policy_p(void)
+{
+ char* api_name = "sound_manager_get_route_policy";
+ sound_route_policy_e route_policy;
+ int ret;
+ if ((ret = sound_manager_get_route_policy(&route_policy)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_route_policy_n(void)
+{
+ char* api_name = "sound_manager_get_route_policy";
+ int ret;
+ if ((ret = sound_manager_get_route_policy(NULL)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_current_sound_type_p(void)
+{
+ char* api_name = "sound_manager_get_current_sound_type";
+ sound_type_e type;
+ int ret;
+ ret = sound_manager_get_current_sound_type(&type);
+ if (ret == SOUND_MANAGER_ERROR_NONE || ret == SOUND_MANAGER_ERROR_NO_PLAYING_SOUND)
+ {
+ dts_pass(api_name);
+ }
+
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_current_sound_type_n(void)
+{
+ char* api_name = "sound_manager_get_current_sound_type";
+ int ret;
+ if ((ret = sound_manager_get_current_sound_type(NULL)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_current_sound_device_p(void)
+{
+ char* api_name = "sound_manager_get_current_sound_device";
+ sound_device_e device;
+ int ret;
+ if ((ret = sound_manager_get_current_sound_device(&device)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_current_sound_device_n(void)
+{
+ char* api_name = "sound_manager_get_current_sound_device";
+ int ret;
+ if ((ret = sound_manager_get_current_sound_device(NULL)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_set_session_type_p(void)
+{
+ char* api_name = "sound_manager_set_session_type";
+ sound_device_e device;
+ int ret;
+ if ((ret = sound_manager_set_session_type(SOUND_SESSION_TYPE_SHARE)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+static void utc_media_sound_manager_set_session_type_n(void)
+{
+ char* api_name = "sound_manager_set_session_type";
+ sound_device_e device;
+ int ret;
+ if ((ret = sound_manager_set_session_type(-1)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_get_a2dp_status_p(void)
+{
+ char* api_name = "sound_manager_get_a2dp_status";
+ bool connected;
+ char *name;
+ int ret;
+ if ((ret = sound_manager_get_a2dp_status(&connected, &name)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+static void utc_media_sound_manager_get_a2dp_status_n(void)
+{
+ char* api_name = "sound_manager_get_a2dp_status";
+ int ret;
+ if ((ret = sound_manager_get_a2dp_status(NULL, NULL)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static bool _sound_available_route_cb (sound_route_e route, void *user_data)
+{
+ return false;
+}
+
+static void utc_media_sound_manager_foreach_available_route_p(void)
+{
+ int ret = sound_manager_foreach_available_route(_sound_available_route_cb, NULL);
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_foreach_available_route_n(void)
+{
+ int ret = sound_manager_foreach_available_route(NULL, NULL);
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_set_active_route_p(void)
+{
+ int ret = sound_manager_set_active_route(SOUND_ROUTE_OUT_SPEAKER);
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_set_active_route_n(void)
+{
+ int ret = sound_manager_set_active_route(SOUND_ROUTE_INOUT_BLUETOOTH+1);
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_get_active_device_p(void)
+{
+ sound_device_in_e in;
+ sound_device_out_e out;
+ int ret = sound_manager_get_active_device(&in, &out);
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_get_active_device_n(void)
+{
+ int ret = sound_manager_get_active_device(NULL, NULL);
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+static void utc_media_sound_manager_is_route_available_p(void)
+{
+ int ret = sound_manager_is_route_available(SOUND_ROUTE_OUT_SPEAKER);
+ dts_check_eq(__func__, ret, true);
+}
+static void utc_media_sound_manager_is_route_available_n(void)
+{
+ int ret = sound_manager_is_route_available(SOUND_ROUTE_INOUT_BLUETOOTH+1);
+ dts_check_ne(__func__, ret, true);
+}
+
+static void utc_media_sound_manager_call_session_create_p(void)
+{
+ sound_call_session_h session;
+ int ret = sound_manager_call_session_create(SOUND_SESSION_TYPE_CALL, &session);
+ if (ret == SOUND_MANAGER_ERROR_NONE)
+ sound_manager_call_session_destroy(session);
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_call_session_create_n(void)
+{
+ int ret = sound_manager_call_session_create(SOUND_SESSION_TYPE_CALL, NULL);
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+static void utc_media_sound_manager_call_session_set_mode_p(void)
+{
+ sound_call_session_h session;
+ int ret = sound_manager_call_session_create(SOUND_SESSION_TYPE_CALL, &session);
+ if (ret != SOUND_MANAGER_ERROR_NONE) {
+ dts_fail(__func__);
+ }
+ ret = sound_manager_call_session_set_mode (session, SOUND_CALL_SESSION_MODE_RINGTONE);
+ sound_manager_call_session_destroy(session);
+
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_call_session_set_mode_n(void)
+{
+ sound_call_session_h session;
+ int ret = sound_manager_call_session_create(SOUND_SESSION_TYPE_CALL, &session);
+ if (ret != SOUND_MANAGER_ERROR_NONE) {
+ dts_fail(__func__);
+ }
+ ret = sound_manager_call_session_set_mode (NULL, SOUND_CALL_SESSION_MODE_RINGTONE);
+ sound_manager_call_session_destroy(session);
+
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+static void utc_media_sound_manager_call_session_get_mode_p(void)
+{
+ sound_call_session_h session;
+ sound_call_session_mode_e mode;
+ int ret = sound_manager_call_session_create(SOUND_SESSION_TYPE_CALL, &session);
+ if (ret != SOUND_MANAGER_ERROR_NONE) {
+ dts_fail(__func__);
+ }
+ ret = sound_manager_call_session_get_mode (session, &mode);
+ sound_manager_call_session_destroy(session);
+
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_call_session_get_mode_n(void)
+{
+ sound_call_session_h session;
+ int ret = sound_manager_call_session_create(SOUND_SESSION_TYPE_CALL, &session);
+ if (ret != SOUND_MANAGER_ERROR_NONE) {
+ dts_fail(__func__);
+ }
+ ret = sound_manager_call_session_get_mode (NULL, NULL);
+ sound_manager_call_session_destroy(session);
+
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_call_session_destroy_p(void)
+{
+ sound_call_session_h session;
+ int ret = sound_manager_call_session_create(SOUND_SESSION_TYPE_CALL, &session);
+ if (ret != SOUND_MANAGER_ERROR_NONE) {
+ dts_fail(__func__);
+ }
+ ret = sound_manager_call_session_destroy(session);
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_call_session_destroy_n(void)
+{
+ int ret = sound_manager_call_session_destroy(NULL);
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
--- /dev/null
+/*
+* Copyright (c) 2011 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 <tet_api.h>
+#include <media/sound_manager.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+static void utc_media_sound_manager_set_volume_changed_cb_p(void);
+static void utc_media_sound_manager_set_volume_changed_cb_n(void);
+static void utc_media_sound_manager_set_route_policy_changed_cb_p(void);
+static void utc_media_sound_manager_set_route_policy_changed_cb_n(void);
+static void utc_media_sound_manager_set_session_notify_cb_p(void);
+static void utc_media_sound_manager_set_session_notify_cb_n(void);
+
+static void utc_media_sound_manager_set_available_route_changed_cb_p(void);
+static void utc_media_sound_manager_set_available_route_changed_cb_n(void);
+static void utc_media_sound_manager_set_active_device_changed_cb_p(void);
+static void utc_media_sound_manager_set_active_device_changed_cb_n(void);
+
+struct tet_testlist tet_testlist[] = {
+ { utc_media_sound_manager_set_volume_changed_cb_p , 1 },
+ { utc_media_sound_manager_set_volume_changed_cb_n , 2 },
+ { utc_media_sound_manager_set_route_policy_changed_cb_p, 3 },
+ { utc_media_sound_manager_set_route_policy_changed_cb_n, 4 },
+ { utc_media_sound_manager_set_session_notify_cb_p, 5 },
+ { utc_media_sound_manager_set_session_notify_cb_n, 6 },
+ { utc_media_sound_manager_set_available_route_changed_cb_p, 7 },
+ { utc_media_sound_manager_set_available_route_changed_cb_n, 8 },
+ { utc_media_sound_manager_set_active_device_changed_cb_p, 9 },
+ { utc_media_sound_manager_set_active_device_changed_cb_n, 10 },
+ { NULL, 0 },
+};
+
+static void startup(void)
+{
+ /* start of TC */
+}
+
+static void cleanup(void)
+{
+ /* end of TC */
+}
+
+static void sound_manager_vol_changed_cb(sound_route_policy_e type, void *user_data)
+{
+}
+
+static void sound_manager_routepolicy_changed_cb(sound_type_e type, unsigned int volume, void *user_data)
+{
+}
+
+static void _sound_available_route_changed_cb (sound_route_e route, bool available, void *user_data)
+{
+}
+
+static void _sound_active_device_changed_cb (sound_device_in_e in, sound_device_out_e out, void *user_data)
+{
+}
+
+static void utc_media_sound_manager_set_volume_changed_cb_p(void)
+{
+ char* api_name = "sound_manager_set_volume_changed_cb";
+ int ret;
+ if ((ret = sound_manager_set_volume_changed_cb(sound_manager_vol_changed_cb, &ret)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ sound_manager_unset_volume_changed_cb();
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_set_volume_changed_cb_n(void)
+{
+ char* api_name = "sound_manager_set_volume_changed_cb";
+ int ret;
+ if ((ret = sound_manager_set_volume_changed_cb(NULL, &ret)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+
+static void utc_media_sound_manager_set_route_policy_changed_cb_p(void)
+{
+ char* api_name = "sound_manager_set_route_policy_changed_cb";
+ int ret;
+ if ((ret = sound_manager_set_route_policy_changed_cb(sound_manager_routepolicy_changed_cb, &ret)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ sound_manager_unset_route_policy_changed_cb();
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_set_route_policy_changed_cb_n(void)
+{
+ char* api_name = "sound_manager_set_route_policy_changed_cb";
+ int ret;
+ if ((ret = sound_manager_set_route_policy_changed_cb(NULL, &ret)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+void _session_notify_cb(sound_session_notify_e notify, void *user_data)
+{
+}
+
+
+static void utc_media_sound_manager_set_session_notify_cb_p(void)
+{
+ char* api_name = "sound_manager_set_route_policy_changed_cb";
+ int ret;
+ if ((ret = sound_manager_set_session_notify_cb(_session_notify_cb, NULL)) == SOUND_MANAGER_ERROR_NONE)
+ {
+ sound_manager_unset_session_notify_cb();
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+
+}
+
+static void utc_media_sound_manager_set_session_notify_cb_n(void)
+{
+ char* api_name = "sound_manager_set_route_policy_changed_cb";
+ int ret;
+ if ((ret = sound_manager_set_session_notify_cb(NULL, NULL)) != SOUND_MANAGER_ERROR_NONE)
+ {
+ sound_manager_unset_session_notify_cb();
+ dts_pass(api_name);
+ }
+ dts_message(api_name, "Call log: %d", ret);
+ dts_fail(api_name);
+}
+
+static void utc_media_sound_manager_set_available_route_changed_cb_p(void)
+{
+ int ret = sound_manager_set_available_route_changed_cb(_sound_available_route_changed_cb, NULL);
+ if (ret == SOUND_MANAGER_ERROR_NONE) {
+ sound_manager_unset_available_route_changed_cb ();
+ }
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_set_available_route_changed_cb_n(void)
+{
+ int ret = sound_manager_set_available_route_changed_cb(NULL, NULL);
+ if (ret == SOUND_MANAGER_ERROR_NONE) {
+ sound_manager_unset_available_route_changed_cb ();
+ }
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_set_active_device_changed_cb_p(void)
+{
+ int ret = sound_manager_set_active_device_changed_cb(_sound_active_device_changed_cb, NULL);
+ if (ret == SOUND_MANAGER_ERROR_NONE) {
+ sound_manager_unset_active_device_changed_cb ();
+ }
+ dts_check_eq(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
+
+static void utc_media_sound_manager_set_active_device_changed_cb_n(void)
+{
+ int ret = sound_manager_set_active_device_changed_cb(NULL, NULL);
+ if (ret == SOUND_MANAGER_ERROR_NONE) {
+ sound_manager_unset_active_device_changed_cb ();
+ }
+ dts_check_ne(__func__, ret, SOUND_MANAGER_ERROR_NONE);
+}
--- /dev/null
+all
+ ^TEST
+##### Scenarios for TEST #####
+
+# Test scenario
+TEST
+ :include:/testcase/tslist
--- /dev/null
+TET_OUTPUT_CAPTURE=True # capture option for build operation checking
+TET_BUILD_TOOL=make # build with using make command
+TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build
+TET_API_COMPLIANT=True # use TET API in Test Case ?
+TET_PASS_TC_NAME=True # report passed TC name in Journal file?
--- /dev/null
+TET_OUTPUT_CAPTURE=True # capture option
+TET_CLEAN_TOOL= make clean # clean tool
+TET_CLEAN_FILE= Makefile # file for clean
+TET_API_COMPLIANT=True # TET API useage
+TET_PASS_TC_NAME=True # showing name , passed TC
--- /dev/null
+TET_OUTPUT_CAPTURE=True # capturing execution or not
+TET_EXEC_TOOL= # ex) exec : execution tool set up/ Optional
+TET_EXEC_FILE= # ex) exectool : execution file/ Optional
+TET_API_COMPLIANT=True # Test case or Tool usesTET API?
+TET_PASS_TC_NAME=True # showing Passed TC name ?
+capi-media-sound-manager (0.1.0-13) unstable; urgency=low
+
+ * package upload
+ * Git: slp-source.sec.samsung.net:framework/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-13
+
+ -- Seungbae Shin <seungbae.shin@samsung.com> Tue, 21 Aug 2012 14:08:35 +0900
+
+capi-media-sound-manager (0.1.0-12) unstable; urgency=low
+
+ * Add interrupted callback API
+ * Git: slp-source.sec.samsung.net:framework/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-12
+
+ -- Seungbae Shin <seungbae.shin@samsung.com> Thu, 16 Aug 2012 13:40:24 +0900
+
+capi-media-sound-manager (0.1.0-11) unstable; urgency=low
+
+ * Add TC for audioroute
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-11
+
+ -- Seungbae Shin <seungbae.shin@samsung.com> Fri, 11 May 2012 16:17:31 +0900
+
+capi-media-sound-manager (0.1.0-10) unstable; urgency=low
+
+ * Add uploader
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-10
+
+ -- Seungbae Shin <seungbae.shin@samsung.com> Fri, 27 Apr 2012 11:24:21 +0900
+
+capi-media-sound-manager (0.1.0-9) unstable; urgency=low
+
+ * CAPI updated for audio route
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-9
+
+ -- Seongho Jeong <sh33.jeong@samsung.com> Thu, 29 Mar 2012 19:41:11 +0900
+
+capi-media-sound-manager (0.1.0-8) unstable; urgency=low
+
+ * add volume key api
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-8
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Mon, 26 Mar 2012 16:31:05 +0900
+
capi-media-sound-manager (0.1.0-7) unstable; urgency=low
* add so version
capi-media-sound-manager (0.1.0-6) unstable; urgency=low
- * Update version
+ * Update error none value
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-6
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Mon, 05 Dec 2011 11:04:34 +0900
+
+capi-media-sound-manager (0.1.0-5) unstable; urgency=low
+
+ * Update sound_manager_set_volume parameter
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-5
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Mon, 05 Dec 2011 10:10:26 +0900
- -- Seungkeun Lee <sngn.lee@samsung.com> Thu, 15 Dec 2011 12:53:31 +0900
+capi-media-sound-manager (0.1.0-4) unstable; urgency=low
+
+ * Update Log formatting
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-4
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Sun, 27 Nov 2011 14:05:10 +0900
+
+capi-media-sound-manager (0.1.0-3) unstable; urgency=low
+
+ * Update namespace
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-3
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Wed, 23 Nov 2011 13:01:46 +0900
+
+capi-media-sound-manager (0.1.0-2) unstable; urgency=low
+
+ * sound_manager_set_session_notify_cb , callback null check
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-2
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Fri, 07 Oct 2011 10:03:00 +0900
+
+capi-media-sound-manager (0.1.0-1) unstable; urgency=low
+
+ * SDK API Baseline
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.1.0-1
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Tue, 27 Sep 2011 17:43:56 +0900
+
+capi-media-sound-manager (0.0.1-4) unstable; urgency=low
+
+ * Update TC
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.0.1-4
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Wed, 31 Aug 2011 19:03:34 +0900
+
+capi-media-sound-manager (0.0.1-3) unstable; urgency=low
+
+ * Update package dependancy
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.0.1-3
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Mon, 29 Aug 2011 14:41:46 +0900
+
+capi-media-sound-manager (0.0.1-2) unstable; urgency=low
+
+ * ERROR name is changed
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.0.1-2
+
+ -- Seungkeun Lee <sngn.lee@samsung.com> Mon, 29 Aug 2011 10:30:41 +0900
capi-media-sound-manager (0.0.1-1) unstable; urgency=low
- * Initial release.
+ * Initial Upload
+ * Git: slp-source.sec.samsung.net:slp/api/sound-manager
+ * Tag: capi-media-sound-manager_0.0.1-1
- -- Seungkeun Lee <sngn.lee@samsung.com> Wed, 07 Dec 2011 12:50:03 +0900
+ -- Seungkeun Lee <sngn.lee@samsung.com> Thu, 04 Aug 2011 17:32:41 +0900
Section: libs
Priority: extra
Maintainer: Seungkeun Lee <sngn.lee@samsung.com>, Kangho Hur<kagho.hur@samsung.com>
+Uploaders: Seungbae Shin <seungbae.shin@samsung.com>
Build-Depends: debhelper (>= 5), libmm-sound-dev , capi-base-common-dev , dlog-dev, libmm-session-dev
Package: capi-media-sound-manager
SOUND_SESSION_NOTIFY_RESUME, /**< Resume : session interrupt of application has ended. */
} sound_session_notify_e;
+/**
+ * @brief Enumerations of audio input device type.
+ */
+typedef enum{
+ SOUND_DEVICE_IN_MIC = 0x01, /**< Device builtin mic. */
+ SOUND_DEVICE_IN_WIRED_ACCESSORY = 0x02, /**< Wired input devices */
+ SOUND_DEVICE_IN_BT_SCO = 0x04, /**< Bluetooth SCO device */
+} sound_device_in_e;
+
+/**
+ * @brief Enumerations of audio output device type.
+ */
+typedef enum{
+ SOUND_DEVICE_OUT_SPEAKER = 0x01<<8, /**< Device builtin speaker */
+ SOUND_DEVICE_OUT_RECEIVER = 0x02<<8, /**< Device builtin receiver */
+ SOUND_DEVICE_OUT_WIRED_ACCESSORY = 0x04<<8, /**< Wired output devices such as headphone, headset, and so on. */
+ SOUND_DEVICE_OUT_BT_SCO = 0x08<<8, /**< Bluetooth SCO device */
+ SOUND_DEVICE_OUT_BT_A2DP = 0x10<<8, /**< Bluetooth A2DP device */
+} sound_device_out_e;
+
+/**
+ * @brief Enumerations of route type.
+ */
+typedef enum{
+ SOUND_ROUTE_OUT_SPEAKER = SOUND_DEVICE_OUT_SPEAKER, /**< Routing audio output to builtin device such as internal speaker. */
+ SOUND_ROUTE_OUT_WIRED_ACCESSORY = SOUND_DEVICE_OUT_WIRED_ACCESSORY,/**< Routing audio output to wired accessory such as headphone, headset, and so on. */
+ SOUND_ROUTE_OUT_BLUETOOTH = SOUND_DEVICE_OUT_BT_A2DP, /**< Routing audio output to bluetooth A2DP. */
+ SOUND_ROUTE_IN_MIC = SOUND_DEVICE_IN_MIC, /**< Routing audio input to device builtin mic. */
+ SOUND_ROUTE_IN_WIRED_ACCESSORY = SOUND_DEVICE_IN_WIRED_ACCESSORY, /**< Routing audio input to wired accessory. */
+ SOUND_ROUTE_IN_MIC_OUT_RECEIVER = SOUND_DEVICE_IN_MIC |SOUND_DEVICE_OUT_RECEIVER, /**< Routing audio input to device builtin mic and routing audio output to builtin receiver*/
+ SOUND_ROUTE_IN_MIC_OUT_SPEAKER = SOUND_DEVICE_IN_MIC |SOUND_DEVICE_OUT_SPEAKER , /**< Routing audio input to device builtin mic and routing audio output to builtin speaker */
+ SOUND_ROUTE_IN_MIC_OUT_HEADPHONE = SOUND_DEVICE_IN_MIC | SOUND_DEVICE_OUT_WIRED_ACCESSORY,/**< Routing audio input to device builtin mic and routing audio output to headphone */
+ SOUND_ROUTE_INOUT_HEADSET = SOUND_DEVICE_IN_WIRED_ACCESSORY | SOUND_DEVICE_OUT_WIRED_ACCESSORY, /**< Routing audio input and output to headset*/
+ SOUND_ROUTE_INOUT_BLUETOOTH = SOUND_DEVICE_IN_BT_SCO |SOUND_DEVICE_OUT_BT_SCO /**< Routing audio input and output to bluetooth SCO */
+} sound_route_e;
+
+/**
+ * @brief Enumerations of call session type
+ */
+typedef enum{
+ SOUND_SESSION_TYPE_CALL = 0, /**< call type */
+ SOUND_SESSION_TYPE_VOIP, /**< voip type */
+} sound_call_session_type_e;
+
+/**
+ * @brief Enumerations of communication session type
+ */
+typedef enum{
+ SOUND_CALL_SESSION_MODE_VOICE = 0, /**< normal voicecall mode */
+ SOUND_CALL_SESSION_MODE_RINGTONE, /**< ringtone mode */
+ SOUND_CALL_SESSION_MODE_MEDIA, /**< media on call mode */
+} sound_call_session_mode_e;
+
+/**
+ * @brief Enumerations of sound interrupted type
+ */
+typedef enum
+{
+ SOUND_INTERRUPTED_COMPLETED = 0, /**< Interrupt completed*/
+ SOUND_INTERRUPTED_BY_OTHER_APP, /**< Interrupted by another application*/
+ SOUND_INTERRUPTED_BY_CALL, /**< Interrupted by incoming call*/
+ SOUND_INTERRUPTED_BY_EARJACK_UNPLUG, /**< Interrupted by unplugging headphone*/
+ SOUND_INTERRUPTED_BY_RESOURCE_CONFLICT, /**< Interrupted by resource conflict*/
+ SOUND_INTERRUPTED_BY_ALARM, /**< Interrupted by alarm*/
+} sound_interrupted_code_e;
+
+/**
+ * @brief Sound call session handle type.
+ */
+typedef struct sound_call_session_s *sound_call_session_h;
/**
* @brief Called when the sound session notification has occured.
typedef void (*sound_session_notify_cb) (sound_session_notify_e notify, void *user_data);
/**
+ * @brief Called when the playing sound was interrupted.
+ * @param[in] code The interrupted code
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre You should register this callback by sound_manager_set_interrupted_cb()
+ * @see sound_manager_set_interrupted_cb()
+ */
+typedef void(* sound_interrupted_cb)(sound_interrupted_code_e code, void *user_data);
+
+
+/**
* @brief Called when the system volume has changed.
* @param[in] type The sound type of changed volume
* @param[in] volume The new volume value
int sound_manager_get_volume(sound_type_e type, int *volume);
/**
- * @brief Sets the application's sound route policy
- * @param[in] route The route policy to set
- * @return 0 on success, otherwise a negative error value
- * @retval #SOUND_MANAGER_ERROR_NONE Success
- * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
- * @see sound_manager_get_route_policy()
- */
-int sound_manager_set_route_policy (sound_route_policy_e route);
-
-/**
- * @brief Gets the current application's route policy
- * @param[out] route The current route policy
- * @return 0 on success, otherwise a negative error value.
- * @retval #SOUND_MANAGER_ERROR_NONE Success
- * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
- * @see sound_manager_set_route_policy()
- */
-int sound_manager_get_route_policy (sound_route_policy_e *route);
-
-/**
* @brief Gets the current playing sound type
* @param[out] type The current sound type
* @return 0 on success, otherwise a negative error value.
* @return 0 on success, otherwise a negative error value.
* @retval #SOUND_MANAGER_ERROR_NONE Success
* @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #SOUND_MANAGER_ERROR_NO_PLAYING_SOUND No playing sound
+ * @retval #SOUND_MANAGER_ERROR_NO_PLAYING_SOUND No playing sound
* @see sound_manager_get_current_sound_type()
*/
int sound_manager_get_current_sound_device(sound_device_e *device);
void sound_manager_unset_volume_changed_cb(void);
/**
- * @brief Registers a callback function to be invoked when the route policy is changed.
- * @param[in] callback Callback function to indicate change in route policy
- * @param[in] user_data The user data to be passed to the callback function
- * @return 0 on success, otherwise a negative error value.
- * @retval #SOUND_MANAGER_ERROR_NONE Success
- * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
- * @post sound_manager_route_policy_changed_cb() will be invoked
- * @see sound_manager_unset_route_policy_changed_cb()
- * @see sound_manager_route_policy_changed_cb()
- */
-int sound_manager_set_route_policy_changed_cb(sound_manager_route_policy_changed_cb callback, void *user_data);
-
-/**
- * @brief Unregisters the callback for sound route policy change
- * @see sound_manager_set_route_policy_changed_cb()
- */
-void sound_manager_unset_route_policy_changed_cb(void);
-
-
-/**
* @brief Gets the A2DP activation information.
* @remarks If @a connected is @c true, @a bt_name must be released with free() by you. If @a connected is @c false, @a bt_name is set to NULL.
* @param[out] connected The Bluetooth A2DP connection status (@c true = connected, @c false = disconnected)
void sound_manager_unset_session_notify_cb(void);
/**
+ * @brief Registers a callback function to be invoked when the playing sound was interrupted.
+ * @param[in] callback The interrupted callback function
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post sound_interrupted_cb() will be invoked
+ * @see sound_manager_unset_interrupted_cb()
+ * @see sound_interrupted_cb()
+ */
+int sound_manager_set_interrupted_cb(sound_interrupted_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function which is called when the playing sound was interrupted
+ * @see sound_manager_set_interrupted_cb()
+ */
+void sound_manager_unset_interrupted_cb(void);
+
+
+
+/**
* @brief Sets the volume key type
* @param[in] type The volume key type to set
* @return 0 on success, otherwise a negative error value.
*/
int sound_manager_set_volume_key_type(volume_key_type_e type);
+/**
+ * @brief Gets called iteratively to notify you of available route.
+ * @param[in] route The available route
+ * @param[in] user_data The user data passed from the foreach function
+ * @return @c true to continue with the next iteration of the loop, \n @c false to break out of the loop
+ * @pre sound_manager_foreach_available_route() will invoke this callback.
+ * @see sound_manager_foreach_available_route()
+ */
+typedef bool(* sound_available_route_cb)(sound_route_e route, void *user_data);
+
+/**
+ * @brief Called when the available audio route is changed.
+ * @param[in] route The audio route
+ * @param[in] available The status of given route
+ * @param[in] user_data The user data passed from the foreach function
+ * @pre sound_manager_foreach_available_route() will invoke this callback.
+ * @see sound_manager_foreach_available_route()
+ */
+typedef void(* sound_available_route_changed_cb)(sound_route_e route, bool available, void *user_data);
+
+/**
+ * @brief Called when the audio route is changed.
+ * @param[in] route The audio route
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre You should register this callback by sound_manager_set_active_device_changed_cb()
+ * @see sound_manager_set_active_device_changed_cb()
+ */
+typedef void(* sound_active_device_changed_cb)(sound_device_in_e in, sound_device_out_e out, void *user_data);
+
+/**
+ * @brief Retrieves all available audio routes by invoking a specific callback for each valid route.
+ * @param[in] callback The session notify callback function
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post sound_available_route_cb() will be invoked
+ * @see sound_available_route_cb()
+ */
+int sound_manager_foreach_available_route (sound_available_route_cb callback, void *user_data);
+
+/**
+ * @brief Changes the audio routes.
+ * @param[in] route The route to set
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see sound_manager_get_active_device()
+ */
+int sound_manager_set_active_route (sound_route_e route);
+
+/**
+ * @brief Changes the audio route.
+ * @param[out] in The current sound input device
+ * @param[out] in The current sound output device
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see sound_manager_set_active_route()
+ */
+int sound_manager_get_active_device (sound_device_in_e *in, sound_device_out_e *out);
+
+/**
+ * @brief Check if given audio route is available or not.
+ * @param[in] route The route to set
+ * @return 0 on success, otherwise a negative error value.
+ * @return @c true if the specified route is supported, \n else @c false
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ */
+bool sound_manager_is_route_available (sound_route_e route);
+
+/**
+ * @brief Registers a callback function to be invoked when the available status is changed.
+ * @param[in] callback The available status changed callback function
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post sound_available_route_changed_cb() will be invoked
+ * @see sound_manager_unset_available_route_changed_cb()
+ * @see sound_available_route_changed_cb()
+ */
+int sound_manager_set_available_route_changed_cb (sound_available_route_changed_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ * @see sound_manager_set_available_route_changed_cb()
+ */
+void sound_manager_unset_available_route_changed_cb (void);
+
+/**
+ * @brief Registers a callback function to be invoked when the audio device is changed.
+ * @param[in] callback The session notify callback function
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post sound_active_device_changed_cb() will be invoked
+ * @see sound_manager_unset_active_device_changed_cb()
+ * @see sound_active_device_changed_cb()
+ */
+int sound_manager_set_active_device_changed_cb (sound_active_device_changed_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function which is called when the route notification is occured.
+ * @see sound_manager_set_active_device_changed_cb()
+ */
+void sound_manager_unset_active_device_changed_cb (void);
+
+/**
+ * @brief Creates a call session handle.
+ * @remarks @a session must be released sound_manager_call_session_destroy() by you.
+ * @param[out] session A new handle to call session
+ * @retval #SOUND_MANAGER_ERROR_NONE Successful
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOUND_MANAGER_OUT_OF_MEMORY Out of memory
+ * @see sound_manager_call_session_destroy()
+ */
+int sound_manager_call_session_create(sound_call_session_type_e type, sound_call_session_h *session);
+
+/**
+ * @brief Sets the call session mode.
+ *
+ * @param[in] session The handle to call session
+ * @param[in] mode The call session mode
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Successful
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see sound_manager_call_session_get_mode()
+ */
+int sound_manager_call_session_set_mode(sound_call_session_h session, sound_call_session_mode_e mode);
+
+/**
+ * @brief Gets the call session mode.
+ *
+ * @param[in] session The handle to call session
+ * @param[out] mode The call session mode
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Successful
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see sound_manager_call_session_set_mode()
+ */
+int sound_manager_call_session_get_mode(sound_call_session_h session, sound_call_session_mode_e *mode);
+
+/**
+ * @brief Destroys the call session handle.
+ *
+ * @param[in] session The handle to call session to be destroyed
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #SOUND_MANAGER_ERROR_NONE Successful
+ * @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see sound_manager_call_session_create()
+ */
+int sound_manager_call_session_destroy(sound_call_session_h session);
/**
* @}
*/
+__attribute__ ((deprecated)) int sound_manager_set_route_policy (sound_route_policy_e route);
+__attribute__ ((deprecated)) int sound_manager_get_route_policy (sound_route_policy_e *route);
+__attribute__ ((deprecated)) int sound_manager_set_route_policy_changed_cb(sound_manager_route_policy_changed_cb callback, void *user_data);
+__attribute__ ((deprecated)) void sound_manager_unset_route_policy_changed_cb(void);
+
+
#ifdef __cplusplus
}
#endif
+#sbs-git:slp/api/sound-manager capi-media-sound-manager 0.1.0 6ac5ae741e8b8dc20b33fc82c3f74602b19732d4
Name: capi-media-sound-manager
Summary: Sound Manager library
-Version: 0.1.0
-Release: 8
+Version: 0.1.0
+Release: 13
Group: TO_BE/FILLED_IN
-License: Apache-2.0
+License: TO BE FILLED IN
Source0: %{name}-%{version}.tar.gz
BuildRequires: cmake
BuildRequires: pkgconfig(dlog)
Requires(postun): /sbin/ldconfig
%description
-A Sound Manager library in Tizen Native API
+A Sound Manager library in Tizen C API
%package devel
Summary: Sound Manager library (Development)
Requires: %{name} = %{version}-%{release}
%description devel
-A Sound Manager library in Tizen Native API (DEV)
+A Sound Manager library in Tizen C API (DEV)
%prep
%setup -q
* 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 <stdio.h>
#include <limits.h>
#include <string.h>
+#include <malloc.h>
#include <unistd.h>
#include <dlog.h>
#include <mm_session.h>
+#include <mm_session_private.h>
#define MAX_VOLUME_TYPE 5
int is_registered;
void *user_data;
sound_session_notify_cb user_cb;
+ void *interrupted_user_data;
+ sound_interrupted_cb interrupted_cb;
}_session_notify_info_s;
+typedef struct {
+ void *user_data;
+ sound_available_route_changed_cb user_cb;
+}_changed_available_route_info_s;
+
+typedef struct {
+ void *user_data;
+ sound_active_device_changed_cb user_cb;
+}_changed_active_device_info_s;
+
static _changed_volume_info_s g_volume_changed_cb_table;
static _changed_policy_info_s g_policy_changed_cb_table;
-static _session_notify_info_s g_session_notify_cb_table = {0, NULL, NULL };
+static _session_notify_info_s g_session_notify_cb_table = {0, NULL, NULL, NULL, NULL};
static void __volume_changed_cb(void *user_data)
{
- sound_type_e type = (sound_type_e)user_data;
-
+ sound_type_e type = (sound_type_e)user_data;
+
int new_volume;
- sound_manager_get_volume( type, &new_volume);
- if( g_volume_changed_cb_table.user_cb )
+ sound_manager_get_volume(type, &new_volume);
+ if(g_volume_changed_cb_table.user_cb)
(g_volume_changed_cb_table.user_cb)(type, new_volume, g_volume_changed_cb_table.user_data);
}
g_policy_changed_cb_table.user_cb(policy, g_policy_changed_cb_table.user_data);
}
-static void __session_notify_cb(session_msg_t msg, void *user_data){
- if( g_session_notify_cb_table.user_cb ){
+static void __session_notify_cb(session_msg_t msg, session_event_t event, void *user_data){
+ if(g_session_notify_cb_table.user_cb){
g_session_notify_cb_table.user_cb(msg, g_session_notify_cb_table.user_data);
}
+ if( g_session_notify_cb_table.interrupted_cb ){
+ sound_interrupted_code_e e = SOUND_INTERRUPTED_COMPLETED;
+ if( msg == MM_SESSION_MSG_STOP )
+ e = SOUND_INTERRUPTED_COMPLETED;
+ else{
+ switch(event){
+ case MM_SESSION_EVENT_OTHER_APP :
+ e = SOUND_INTERRUPTED_BY_OTHER_APP;
+ break;
+ case MM_SESSION_EVENT_CALL :
+ e = SOUND_INTERRUPTED_BY_CALL;
+ break;
+ case MM_SESSION_EVENT_ALARM :
+ e = SOUND_INTERRUPTED_BY_ALARM;
+ break;
+ case MM_SESSION_EVENT_EARJACK_UNPLUG:
+ e = SOUND_INTERRUPTED_BY_EARJACK_UNPLUG;
+ break;
+ case MM_SESSION_EVENT_RESOURCE_CONFLICT:
+ e = SOUND_INTERRUPTED_BY_RESOURCE_CONFLICT;
+ break;
+ default :
+ e = SOUND_INTERRUPTED_BY_OTHER_APP;
+ break;
+ }
+ }
+ g_session_notify_cb_table.interrupted_cb(e, g_session_notify_cb_table.interrupted_user_data);
+ }
}
-
static int __convert_sound_manager_error_code(const char *func, int code){
int ret = SOUND_MANAGER_ERROR_NONE;
char *errorstr = NULL;
-
+
switch(code)
{
case SOUND_MANAGER_ERROR_INVALID_PARAMETER:
ret = SOUND_MANAGER_ERROR_NONE;
errorstr = "ERROR_NONE";
break;
- case MM_ERROR_INVALID_ARGUMENT:
+ case MM_ERROR_INVALID_ARGUMENT:
case MM_ERROR_SOUND_INVALID_POINTER:
ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
errorstr = "INVALID_PARAMETER";
break;
case MM_ERROR_SOUND_INTERNAL:
ret = SOUND_MANAGER_ERROR_INVALID_OPERATION;
- errorstr = "INVALID_OPERATION" ;
+ errorstr = "INVALID_OPERATION" ;
break;
case MM_ERROR_SOUND_VOLUME_NO_INSTANCE:
case MM_ERROR_SOUND_VOLUME_CAPTURE_ONLY:
ret = SOUND_MANAGER_ERROR_NO_PLAYING_SOUND;
- errorstr = "NO_PLAYING_SOUND" ;
+ errorstr = "NO_PLAYING_SOUND" ;
break;
- }
- LOGE( "[%s] %s(0x%08x) : core frameworks error code(0x%08x)",func, errorstr, ret, code);
+ }
+ LOGE("[%s] %s(0x%08x) : core frameworks error code(0x%08x)",func, errorstr, ret, code);
return ret;
}
-
-
-
int sound_manager_get_max_volume(sound_type_e type, int *max)
{
int volume;
- if( max == NULL )
+ if(max == NULL)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
-
- if( type > MAX_VOLUME_TYPE || type < 0 )
+
+ if(type > MAX_VOLUME_TYPE || type < 0)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
int ret = mm_sound_volume_get_step(type, &volume);
- if( ret == 0 )
+ if(ret == 0)
*max = volume -1; // actual volume step can be max step - 1
-
+
return __convert_sound_manager_error_code(__func__, ret);
}
int sound_manager_set_volume(sound_type_e type, int volume)
{
- if( type > MAX_VOLUME_TYPE || type < 0 )
+ if(type > MAX_VOLUME_TYPE || type < 0)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
- if( volume < 0 )
+ if(volume < 0)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
int ret = mm_sound_volume_set_value(type, volume);
int sound_manager_get_volume(sound_type_e type, int *volume)
{
unsigned int uvolume;
- if( type > MAX_VOLUME_TYPE || type < 0 )
+ if(type > MAX_VOLUME_TYPE || type < 0)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
- if( volume == NULL)
+ if(volume == NULL)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
int ret = mm_sound_volume_get_value(type, &uvolume);
- if( ret == 0)
+ if(ret == 0)
*volume = uvolume;
-
+
return __convert_sound_manager_error_code(__func__, ret);
}
int ret;
ret = mm_sound_route_set_system_policy(route);
-
+
return __convert_sound_manager_error_code(__func__, ret);
}
int sound_manager_get_current_sound_type(sound_type_e *type)
{
- if( type == NULL)
+ if(type == NULL)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
int ret;
ret = mm_sound_volume_get_current_playing_type((volume_type_t *)type);
int sound_manager_set_volume_changed_cb(sound_manager_volume_changed_cb callback, void* user_data)
{
- if( callback == NULL )
+ if(callback == NULL)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
int i;
g_volume_changed_cb_table.user_cb = callback;
g_volume_changed_cb_table.user_data = user_data;
for(i = 0 ; i <= MAX_VOLUME_TYPE ; i++)
{
- mm_sound_volume_add_callback( i , __volume_changed_cb ,(void*) i);
+ mm_sound_volume_add_callback(i , __volume_changed_cb ,(void*) i);
}
return 0;
}
int i;
for(i = 0 ; i <= MAX_VOLUME_TYPE ; i++)
{
- mm_sound_volume_remove_callback( i );
+ mm_sound_volume_remove_callback(i);
}
g_volume_changed_cb_table.user_cb = NULL;
g_volume_changed_cb_table.user_data = NULL;
if( callback == NULL)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
g_policy_changed_cb_table.user_cb = callback;
- g_policy_changed_cb_table.user_data = user_data;
+ g_policy_changed_cb_table.user_data = user_data;
mm_sound_route_add_change_callback(__policy_changed_cb, user_data);
return 0;
}
{
mm_sound_route_remove_change_callback();
g_policy_changed_cb_table.user_cb = NULL;
- g_policy_changed_cb_table.user_data = NULL;
+ g_policy_changed_cb_table.user_data = NULL;
}
int sound_manager_get_a2dp_status(bool *connected , char** bt_name){
- int ret;
- int connect;
- ret = mm_sound_route_get_a2dp_status(&connect , bt_name );
- if( ret == 0 )
- *connected = connect;
+ int ret = mm_sound_route_get_a2dp_status((int*)connected , bt_name);
+
return __convert_sound_manager_error_code(__func__, ret);
}
-
-
int sound_manager_set_session_type(sound_session_type_e type){
int ret = 0;
- if( type < 0 || type > SOUND_SESSION_TYPE_EXCLUSIVE )
+ if(type < 0 || type > SOUND_SESSION_TYPE_EXCLUSIVE)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
-
- if( g_session_notify_cb_table.is_registered ){
+
+ if(g_session_notify_cb_table.is_registered){
mm_session_finish();
g_session_notify_cb_table.is_registered = 0;
}
- ret = mm_session_init_ex( type , __session_notify_cb, NULL);
- if( ret == 0 ){
+ ret = mm_session_init_ex(type , __session_notify_cb, NULL);
+ if(ret == 0){
g_session_notify_cb_table.is_registered = 1;
}
return __convert_sound_manager_error_code(__func__, ret);
int sound_manager_set_session_notify_cb(sound_session_notify_cb callback , void *user_data){
int ret =0 ;
- if( callback == NULL)
+ if(callback == NULL)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
-
-
- if( g_session_notify_cb_table.is_registered ==0 ){
- ret = mm_session_init_ex( SOUND_SESSION_TYPE_SHARE /*default*/ , __session_notify_cb, NULL);
- if( ret != 0 )
+
+
+ if(g_session_notify_cb_table.is_registered ==0){
+ ret = mm_session_init_ex(SOUND_SESSION_TYPE_SHARE /*default*/ , __session_notify_cb, NULL);
+ if(ret != 0)
return __convert_sound_manager_error_code(__func__, ret);
g_session_notify_cb_table.is_registered = 1;
}
- g_session_notify_cb_table.user_cb = callback ;
+ g_session_notify_cb_table.user_cb = callback;
g_session_notify_cb_table.user_data = user_data;
return SOUND_MANAGER_ERROR_NONE;
}
void sound_manager_unset_session_notify_cb(void){
- g_session_notify_cb_table.user_cb = NULL;
+ g_session_notify_cb_table.user_cb = NULL;
g_session_notify_cb_table.user_data = NULL;
}
+int sound_manager_set_interrupted_cb(sound_interrupted_cb callback, void *user_data){
+ int ret =0 ;
+ if(callback == NULL)
+ return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+
+ if(g_session_notify_cb_table.is_registered ==0){
+ ret = mm_session_init_ex(SOUND_SESSION_TYPE_SHARE /*default*/ , __session_notify_cb, NULL);
+ if(ret != 0)
+ return __convert_sound_manager_error_code(__func__, ret);
+ g_session_notify_cb_table.is_registered = 1;
+ }
+
+ g_session_notify_cb_table.interrupted_cb= callback;
+ g_session_notify_cb_table.interrupted_user_data = user_data;
+ return SOUND_MANAGER_ERROR_NONE;
+}
+
+void sound_manager_unset_interrupted_cb(void){
+ g_session_notify_cb_table.interrupted_cb= NULL;
+ g_session_notify_cb_table.interrupted_user_data = NULL;
+}
+
int sound_manager_set_volume_key_type(volume_key_type_e type){
- if( type < VOLUME_KEY_TYPE_NONE || type > VOLUME_KEY_TYPE_CALL )
+ if(type < VOLUME_KEY_TYPE_NONE || type > VOLUME_KEY_TYPE_CALL)
return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
int ret;
- if( type == VOLUME_KEY_TYPE_NONE )
+ if(type == VOLUME_KEY_TYPE_NONE)
ret = mm_sound_volume_primary_type_clear();
else
ret = mm_sound_volume_primary_type_set(type);
return __convert_sound_manager_error_code(__func__, ret);
}
+int sound_manager_foreach_available_route (sound_available_route_cb callback, void *user_data)
+{
+ int ret;
+ ret = mm_sound_foreach_available_route_cb((mm_sound_available_route_cb)callback, user_data);
+
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_set_active_route (sound_route_e route)
+{
+ int ret;
+ ret = mm_sound_set_active_route(route);
+
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_get_active_device (sound_device_in_e *in, sound_device_out_e *out)
+{
+ int ret;
+ ret = mm_sound_get_active_device((mm_sound_device_in *)in, (mm_sound_device_out *)out);
+
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+bool sound_manager_is_route_available (sound_route_e route)
+{
+ bool is_available;
+ mm_sound_is_route_available(route, &is_available);
+
+ return is_available;
+}
+
+int sound_manager_set_available_route_changed_cb (sound_available_route_changed_cb callback, void *user_data)
+{
+ int ret;
+ ret = mm_sound_add_available_route_changed_callback((mm_sound_available_route_changed_cb)callback, user_data);
+
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+void sound_manager_unset_available_route_changed_cb (void)
+{
+ mm_sound_remove_available_route_changed_callback();
+}
+
+int sound_manager_set_active_device_changed_cb (sound_active_device_changed_cb callback, void *user_data)
+{
+ int ret;
+ ret = mm_sound_add_active_device_changed_callback((mm_sound_active_device_changed_cb)callback, user_data);
+
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+void sound_manager_unset_active_device_changed_cb (void)
+{
+ mm_sound_remove_active_device_changed_callback();
+}
+
+struct sound_call_session_s
+{
+ int unused;
+};
+
+int sound_manager_call_session_create(sound_call_session_type_e type, sound_call_session_h *session)
+{
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ sound_call_session_h handle = NULL;
+
+ if(type < SOUND_SESSION_TYPE_CALL || type > SOUND_SESSION_TYPE_VOIP || session == NULL) {
+ ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
+ goto ERROR;
+ }
+
+ handle = malloc(sizeof(struct sound_call_session_s));
+
+ if(!handle) {
+ ret = SOUND_MANAGER_ERROR_INVALID_OPERATION;
+ goto ERROR;
+ }
+
+ memset(handle, 0, sizeof(struct sound_call_session_s));
+
+ switch(type) {
+ case SOUND_SESSION_TYPE_CALL:
+ ret = mm_session_init(MM_SESSION_TYPE_CALL);
+ break;
+ case SOUND_SESSION_TYPE_VOIP:
+ ret = mm_session_init(MM_SESSION_TYPE_VIDEOCALL);
+ break;
+ }
+
+ if(ret != MM_ERROR_NONE)
+ goto ERROR;
+
+ *session = handle;
+
+ return SOUND_MANAGER_ERROR_NONE;
+
+ERROR:
+ if(handle)
+ free(handle);
+
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_call_session_set_mode(sound_call_session_h session, sound_call_session_mode_e mode)
+{
+ int ret = SOUND_MANAGER_ERROR_NONE;
+
+ if(mode < SOUND_CALL_SESSION_MODE_VOICE || mode > SOUND_CALL_SESSION_MODE_MEDIA || session == NULL) {
+ ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
+ goto ERROR;
+ }
+
+ ret = mm_session_set_subsession ((mm_subsession_t)mode);
+
+ if(ret != MM_ERROR_NONE)
+ goto ERROR;
+
+ return SOUND_MANAGER_ERROR_NONE;
+
+ERROR:
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_call_session_get_mode(sound_call_session_h session, sound_call_session_mode_e *mode)
+{
+ int ret = SOUND_MANAGER_ERROR_NONE;
+
+ if(mode == NULL || session == NULL) {
+ ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
+ goto ERROR;
+ }
+
+ ret = mm_session_get_subsession ((mm_subsession_t *)mode);
+
+ if(ret != MM_ERROR_NONE)
+ goto ERROR;
+
+ return SOUND_MANAGER_ERROR_NONE;
+
+ERROR:
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_call_session_destroy(sound_call_session_h session)
+{
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ sound_call_session_h *handle = (sound_call_session_h *)session;
+
+ if(session == NULL) {
+ ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
+ goto ERROR;
+ }
+
+ ret = mm_session_finish();
+
+ if(ret != MM_ERROR_NONE)
+ goto ERROR;
+
+ if(handle)
+ free(handle);
+
+ return SOUND_MANAGER_ERROR_NONE;
+
+ERROR:
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
projects / framework / api / sound-manager.git / commitdiff