From: Seungbae Shin Date: Tue, 21 Aug 2012 11:55:17 +0000 (+0900) Subject: 2.0 init X-Git-Tag: 2.0_alpha~3 X-Git-Url: http://review.tizen.org/git/?p=framework%2Fapi%2Fsound-manager.git;a=commitdiff_plain;h=5d93f3ecabbdfcc413d96795203ced6af2e7799d 2.0 init Change-Id: Ieee4f1066b678175f1a911d6c3f3d9e34abaf500 --- diff --git a/TC/_export_env.sh b/TC/_export_env.sh new file mode 100755 index 0000000..72a11ec --- /dev/null +++ b/TC/_export_env.sh @@ -0,0 +1,8 @@ +#!/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 diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh new file mode 100755 index 0000000..5ddaa53 --- /dev/null +++ b/TC/_export_target_env.sh @@ -0,0 +1,7 @@ +#!/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 diff --git a/TC/build.sh b/TC/build.sh new file mode 100755 index 0000000..72aad6c --- /dev/null +++ b/TC/build.sh @@ -0,0 +1,16 @@ +#!/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 diff --git a/TC/clean.sh b/TC/clean.sh new file mode 100755 index 0000000..29743e0 --- /dev/null +++ b/TC/clean.sh @@ -0,0 +1,11 @@ +#!/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 diff --git a/TC/config.default b/TC/config.default new file mode 100644 index 0000000..12ac1e2 --- /dev/null +++ b/TC/config.default @@ -0,0 +1,3 @@ +CAPI_PROJECT_ROOT=/home/abyss/capi +TET_INSTALL_HOST_PATH=/home/abyss/TETware +TET_INSTALL_TARGET_PATH=/mnt/nfs/TETware diff --git a/TC/execute.sh b/TC/execute.sh new file mode 100755 index 0000000..a4f6095 --- /dev/null +++ b/TC/execute.sh @@ -0,0 +1,15 @@ +#!/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 diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile new file mode 100755 index 0000000..0b40f5d --- /dev/null +++ b/TC/testcase/Makefile @@ -0,0 +1,25 @@ +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) diff --git a/TC/testcase/tslist b/TC/testcase/tslist new file mode 100644 index 0000000..12c7ee4 --- /dev/null +++ b/TC/testcase/tslist @@ -0,0 +1,2 @@ +/testcase/utc_media_sound_manager +/testcase/utc_media_sound_manager_callback \ No newline at end of file diff --git a/TC/testcase/utc_media_sound_manager.c b/TC/testcase/utc_media_sound_manager.c new file mode 100755 index 0000000..b892cb9 --- /dev/null +++ b/TC/testcase/utc_media_sound_manager.c @@ -0,0 +1,479 @@ +/* +* 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 +#include + +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); +} diff --git a/TC/testcase/utc_media_sound_manager_callback.c b/TC/testcase/utc_media_sound_manager_callback.c new file mode 100755 index 0000000..cc0f7bd --- /dev/null +++ b/TC/testcase/utc_media_sound_manager_callback.c @@ -0,0 +1,203 @@ +/* +* 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 +#include + +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); +} diff --git a/TC/tet_scen b/TC/tet_scen new file mode 100755 index 0000000..03f029a --- /dev/null +++ b/TC/tet_scen @@ -0,0 +1,7 @@ +all + ^TEST +##### Scenarios for TEST ##### + +# Test scenario +TEST + :include:/testcase/tslist diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg new file mode 100644 index 0000000..f7eda55 --- /dev/null +++ b/TC/tetbuild.cfg @@ -0,0 +1,5 @@ +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? diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg new file mode 100644 index 0000000..02d7030 --- /dev/null +++ b/TC/tetclean.cfg @@ -0,0 +1,5 @@ +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 diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg new file mode 100644 index 0000000..ef3e452 --- /dev/null +++ b/TC/tetexec.cfg @@ -0,0 +1,5 @@ +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 ? diff --git a/capi-media-sound-manager.pc.in b/capi-media-sound-manager.pc.in old mode 100755 new mode 100644 diff --git a/debian/README b/debian/README old mode 100755 new mode 100644 diff --git a/debian/capi-media-sound-manager-dev.install b/debian/capi-media-sound-manager-dev.install old mode 100755 new mode 100644 diff --git a/debian/capi-media-sound-manager-dev.postinst b/debian/capi-media-sound-manager-dev.postinst old mode 100755 new mode 100644 diff --git a/debian/capi-media-sound-manager.install b/debian/capi-media-sound-manager.install old mode 100755 new mode 100644 diff --git a/debian/capi-media-sound-manager.postinst b/debian/capi-media-sound-manager.postinst old mode 100755 new mode 100644 diff --git a/debian/changelog b/debian/changelog old mode 100755 new mode 100644 index c520e2d..c1cef8b --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,51 @@ +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 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 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 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 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 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 Mon, 26 Mar 2012 16:31:05 +0900 + capi-media-sound-manager (0.1.0-7) unstable; urgency=low * add so version @@ -8,12 +56,80 @@ capi-media-sound-manager (0.1.0-7) unstable; urgency=low 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 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 Mon, 05 Dec 2011 10:10:26 +0900 - -- Seungkeun Lee 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 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 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 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 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 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 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 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 Wed, 07 Dec 2011 12:50:03 +0900 + -- Seungkeun Lee Thu, 04 Aug 2011 17:32:41 +0900 diff --git a/debian/compat b/debian/compat old mode 100755 new mode 100644 diff --git a/debian/control b/debian/control index 7e86f64..d7f6906 100755 --- a/debian/control +++ b/debian/control @@ -3,6 +3,7 @@ Source: capi-media-sound-manager Section: libs Priority: extra Maintainer: Seungkeun Lee , Kangho Hur +Uploaders: Seungbae Shin Build-Depends: debhelper (>= 5), libmm-sound-dev , capi-base-common-dev , dlog-dev, libmm-session-dev Package: capi-media-sound-manager diff --git a/include/sound_manager.h b/include/sound_manager.h index 630929e..edad930 100755 --- a/include/sound_manager.h +++ b/include/sound_manager.h @@ -111,6 +111,76 @@ typedef enum{ 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. @@ -122,6 +192,16 @@ typedef enum{ 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 @@ -178,26 +258,6 @@ int sound_manager_set_volume(sound_type_e type, int volume); 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. @@ -217,7 +277,7 @@ int sound_manager_get_current_sound_type(sound_type_e *type); * @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); @@ -242,26 +302,6 @@ int sound_manager_set_volume_changed_cb(sound_manager_volume_changed_cb callback 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) @@ -303,6 +343,27 @@ int sound_manager_set_session_notify_cb(sound_session_notify_cb callback, void * 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. @@ -311,11 +372,171 @@ void sound_manager_unset_session_notify_cb(void); */ 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 diff --git a/packaging/capi-media-sound-manager.spec b/packaging/capi-media-sound-manager.spec old mode 100755 new mode 100644 index bba5fa2..8cee237 --- a/packaging/capi-media-sound-manager.spec +++ b/packaging/capi-media-sound-manager.spec @@ -1,9 +1,10 @@ +#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) @@ -14,7 +15,7 @@ Requires(post): /sbin/ldconfig 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) @@ -22,7 +23,7 @@ Group: TO_BE/FILLED_IN 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 diff --git a/src/sound_manager.c b/src/sound_manager.c index 9179195..555d7c2 100755 --- a/src/sound_manager.c +++ b/src/sound_manager.c @@ -11,7 +11,7 @@ * 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. */ @@ -23,9 +23,11 @@ #include #include #include +#include #include #include #include +#include #define MAX_VOLUME_TYPE 5 @@ -43,19 +45,31 @@ typedef struct { 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); } @@ -64,17 +78,44 @@ static void __policy_changed_cb(void *user_data, system_audio_route_t policy){ 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: @@ -85,49 +126,46 @@ static int __convert_sound_manager_error_code(const char *func, int code){ 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); @@ -138,15 +176,15 @@ int sound_manager_set_volume(sound_type_e type, int 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); } @@ -157,7 +195,7 @@ int sound_manager_set_route_policy (sound_route_policy_e route) int ret; ret = mm_sound_route_set_system_policy(route); - + return __convert_sound_manager_error_code(__func__, ret); } @@ -173,7 +211,7 @@ int sound_manager_get_route_policy (sound_route_policy_e *route) 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); @@ -192,14 +230,14 @@ int sound_manager_get_current_sound_device(sound_device_e *device) 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; } @@ -209,7 +247,7 @@ void sound_manager_unset_volume_changed_cb(void) 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; @@ -220,7 +258,7 @@ int sound_manager_set_route_policy_changed_cb(sound_manager_route_policy_changed 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; } @@ -229,32 +267,27 @@ void sound_manager_unset_route_policy_changed_cb(void) { 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); @@ -262,33 +295,55 @@ int sound_manager_set_session_type(sound_session_type_e type){ 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); @@ -296,3 +351,172 @@ int sound_manager_set_volume_key_type(volume_key_type_e 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); +} + diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt old mode 100755 new mode 100644 diff --git a/test/multimedia_sound_manager_test.c b/test/multimedia_sound_manager_test.c old mode 100755 new mode 100644