-Seungkeun Lee <sngn.lee@samsung.com>
-Kangho Hur <kanho.hur@samsung.com>
-Seungbae Shin <seungbae.shin at samsung.com>
+Seungbae Shin <seungbae.shin@samsung.com>
+Sangchul Lee <sc11.lee@samsung.com>
SET(project_prefix "capi")
SET(prefix "/usr")
SET(version "0.0.1")
-SET(maintainer "Seungkeun Lee <sngn.lee@samsung.com>, Kangho Hur<kagho.hur@samsung.com>")
SET(description "A Sound Manager library in Tizen Native API")
SET(service "media")
SET(submodule "sound-manager")
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
ENDFOREACH(flag)
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror")
+#SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -DTEMP_COMMENT_UNTIL_MM_SOUND_READY")
SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
IF("${ARCH}" STREQUAL "arm")
)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
-#ADD_SUBDIRECTORY(test)
+ADD_SUBDIRECTORY(test)
IF(UNIX)
-Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
-
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- 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.
-
-
-
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+\r
+ Apache License\r
+ Version 2.0, January 2004\r
+ http://www.apache.org/licenses/\r
+\r
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\r
+\r
+ 1. Definitions.\r
+\r
+ "License" shall mean the terms and conditions for use, reproduction,\r
+ and distribution as defined by Sections 1 through 9 of this document.\r
+\r
+ "Licensor" shall mean the copyright owner or entity authorized by\r
+ the copyright owner that is granting the License.\r
+\r
+ "Legal Entity" shall mean the union of the acting entity and all\r
+ other entities that control, are controlled by, or are under common\r
+ control with that entity. For the purposes of this definition,\r
+ "control" means (i) the power, direct or indirect, to cause the\r
+ direction or management of such entity, whether by contract or\r
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the\r
+ outstanding shares, or (iii) beneficial ownership of such entity.\r
+\r
+ "You" (or "Your") shall mean an individual or Legal Entity\r
+ exercising permissions granted by this License.\r
+\r
+ "Source" form shall mean the preferred form for making modifications,\r
+ including but not limited to software source code, documentation\r
+ source, and configuration files.\r
+\r
+ "Object" form shall mean any form resulting from mechanical\r
+ transformation or translation of a Source form, including but\r
+ not limited to compiled object code, generated documentation,\r
+ and conversions to other media types.\r
+\r
+ "Work" shall mean the work of authorship, whether in Source or\r
+ Object form, made available under the License, as indicated by a\r
+ copyright notice that is included in or attached to the work\r
+ (an example is provided in the Appendix below).\r
+\r
+ "Derivative Works" shall mean any work, whether in Source or Object\r
+ form, that is based on (or derived from) the Work and for which the\r
+ editorial revisions, annotations, elaborations, or other modifications\r
+ represent, as a whole, an original work of authorship. For the purposes\r
+ of this License, Derivative Works shall not include works that remain\r
+ separable from, or merely link (or bind by name) to the interfaces of,\r
+ the Work and Derivative Works thereof.\r
+\r
+ "Contribution" shall mean any work of authorship, including\r
+ the original version of the Work and any modifications or additions\r
+ to that Work or Derivative Works thereof, that is intentionally\r
+ submitted to Licensor for inclusion in the Work by the copyright owner\r
+ or by an individual or Legal Entity authorized to submit on behalf of\r
+ the copyright owner. For the purposes of this definition, "submitted"\r
+ means any form of electronic, verbal, or written communication sent\r
+ to the Licensor or its representatives, including but not limited to\r
+ communication on electronic mailing lists, source code control systems,\r
+ and issue tracking systems that are managed by, or on behalf of, the\r
+ Licensor for the purpose of discussing and improving the Work, but\r
+ excluding communication that is conspicuously marked or otherwise\r
+ designated in writing by the copyright owner as "Not a Contribution."\r
+\r
+ "Contributor" shall mean Licensor and any individual or Legal Entity\r
+ on behalf of whom a Contribution has been received by Licensor and\r
+ subsequently incorporated within the Work.\r
+\r
+ 2. Grant of Copyright License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ copyright license to reproduce, prepare Derivative Works of,\r
+ publicly display, publicly perform, sublicense, and distribute the\r
+ Work and such Derivative Works in Source or Object form.\r
+\r
+ 3. Grant of Patent License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ (except as stated in this section) patent license to make, have made,\r
+ use, offer to sell, sell, import, and otherwise transfer the Work,\r
+ where such license applies only to those patent claims licensable\r
+ by such Contributor that are necessarily infringed by their\r
+ Contribution(s) alone or by combination of their Contribution(s)\r
+ with the Work to which such Contribution(s) was submitted. If You\r
+ institute patent litigation against any entity (including a\r
+ cross-claim or counterclaim in a lawsuit) alleging that the Work\r
+ or a Contribution incorporated within the Work constitutes direct\r
+ or contributory patent infringement, then any patent licenses\r
+ granted to You under this License for that Work shall terminate\r
+ as of the date such litigation is filed.\r
+\r
+ 4. Redistribution. You may reproduce and distribute copies of the\r
+ Work or Derivative Works thereof in any medium, with or without\r
+ modifications, and in Source or Object form, provided that You\r
+ meet the following conditions:\r
+\r
+ (a) You must give any other recipients of the Work or\r
+ Derivative Works a copy of this License; and\r
+\r
+ (b) You must cause any modified files to carry prominent notices\r
+ stating that You changed the files; and\r
+\r
+ (c) You must retain, in the Source form of any Derivative Works\r
+ that You distribute, all copyright, patent, trademark, and\r
+ attribution notices from the Source form of the Work,\r
+ excluding those notices that do not pertain to any part of\r
+ the Derivative Works; and\r
+\r
+ (d) If the Work includes a "NOTICE" text file as part of its\r
+ distribution, then any Derivative Works that You distribute must\r
+ include a readable copy of the attribution notices contained\r
+ within such NOTICE file, excluding those notices that do not\r
+ pertain to any part of the Derivative Works, in at least one\r
+ of the following places: within a NOTICE text file distributed\r
+ as part of the Derivative Works; within the Source form or\r
+ documentation, if provided along with the Derivative Works; or,\r
+ within a display generated by the Derivative Works, if and\r
+ wherever such third-party notices normally appear. The contents\r
+ of the NOTICE file are for informational purposes only and\r
+ do not modify the License. You may add Your own attribution\r
+ notices within Derivative Works that You distribute, alongside\r
+ or as an addendum to the NOTICE text from the Work, provided\r
+ that such additional attribution notices cannot be construed\r
+ as modifying the License.\r
+\r
+ You may add Your own copyright statement to Your modifications and\r
+ may provide additional or different license terms and conditions\r
+ for use, reproduction, or distribution of Your modifications, or\r
+ for any such Derivative Works as a whole, provided Your use,\r
+ reproduction, and distribution of the Work otherwise complies with\r
+ the conditions stated in this License.\r
+\r
+ 5. Submission of Contributions. Unless You explicitly state otherwise,\r
+ any Contribution intentionally submitted for inclusion in the Work\r
+ by You to the Licensor shall be under the terms and conditions of\r
+ this License, without any additional terms or conditions.\r
+ Notwithstanding the above, nothing herein shall supersede or modify\r
+ the terms of any separate license agreement you may have executed\r
+ with Licensor regarding such Contributions.\r
+\r
+ 6. Trademarks. This License does not grant permission to use the trade\r
+ names, trademarks, service marks, or product names of the Licensor,\r
+ except as required for reasonable and customary use in describing the\r
+ origin of the Work and reproducing the content of the NOTICE file.\r
+\r
+ 7. Disclaimer of Warranty. Unless required by applicable law or\r
+ agreed to in writing, Licensor provides the Work (and each\r
+ Contributor provides its Contributions) on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\r
+ implied, including, without limitation, any warranties or conditions\r
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\r
+ PARTICULAR PURPOSE. You are solely responsible for determining the\r
+ appropriateness of using or redistributing the Work and assume any\r
+ risks associated with Your exercise of permissions under this License.\r
+\r
+ 8. Limitation of Liability. In no event and under no legal theory,\r
+ whether in tort (including negligence), contract, or otherwise,\r
+ unless required by applicable law (such as deliberate and grossly\r
+ negligent acts) or agreed to in writing, shall any Contributor be\r
+ liable to You for damages, including any direct, indirect, special,\r
+ incidental, or consequential damages of any character arising as a\r
+ result of this License or out of the use or inability to use the\r
+ Work (including but not limited to damages for loss of goodwill,\r
+ work stoppage, computer failure or malfunction, or any and all\r
+ other commercial damages or losses), even if such Contributor\r
+ has been advised of the possibility of such damages.\r
+\r
+ 9. Accepting Warranty or Additional Liability. While redistributing\r
+ the Work or Derivative Works thereof, You may choose to offer,\r
+ and charge a fee for, acceptance of support, warranty, indemnity,\r
+ or other liability obligations and/or rights consistent with this\r
+ License. However, in accepting such obligations, You may act only\r
+ on Your own behalf and on Your sole responsibility, not on behalf\r
+ of any other Contributor, and only if You agree to indemnify,\r
+ defend, and hold each Contributor harmless for any liability\r
+ incurred by, or claims asserted against, such Contributor by reason\r
+ of your accepting any such warranty or additional liability.\r
+\r
+ END OF TERMS AND CONDITIONS\r
+\r
+ APPENDIX: How to apply the Apache License to your work.\r
+\r
+ To apply the Apache License to your work, attach the following\r
+ boilerplate notice, with the fields enclosed by brackets "[]"\r
+ replaced with your own identifying information. (Don't include\r
+ the brackets!) The text should be enclosed in the appropriate\r
+ comment syntax for the file format. We also recommend that a\r
+ file or class name and description of purpose be included on the\r
+ same "printed page" as the copyright notice for easier\r
+ identification within third-party archives.\r
+\r
+ Copyright [yyyy] [name of copyright owner]\r
+\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+\r
+\r
+\r
+++ /dev/null
-Copyright (c) Samsung Electronics Co., Ltd. All rights reserved.
-Except as noted, this software is licensed under Apache License, Version 2.
-Please, see the LICENSE file for Apache License terms and conditions.
--- /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.
+ */
+
+
+#ifndef __TIZEN_MEDIA_SOUND_MANAGER_DOC_H__
+#define __TIZEN_MEDIA_SOUND_MANAGER_DOC_H__
+
+
+/**
+ * @file sound_manager_doc.h
+ * @brief This file contains high level documentation of the Sound Manager API.
+ */
+
+/**
+ * @ingroup CAPI_MEDIA_FRAMEWORK
+ * @defgroup CAPI_MEDIA_SOUND_MANAGER_MODULE Sound Manager
+ * @brief The @ref CAPI_MEDIA_SOUND_MANAGER_MODULE API provides functions to get and set sound parameters like volume and session policy.
+ *
+ * @section CAPI_MEDIA_SOUND_MANAGER_MODULE_HEADER Required Header
+ * \#include <sound_manager.h>
+ *
+ * @section CAPI_MEDIA_SOUND_MANAGER_OVERVIEW Overview
+ * The Sound Manager service allows APIs to manage audio output.
+ *
+ * The Sound Manager API allows you to:
+ * - check/control output volumes
+ * - handle a volume changed notification
+ * - determine a sound session policy
+ * - handle the notification of a sound session interruption
+ * - query the basic information of connected sound devices
+ * - handle the notification for connection of a sound device, and for changed information of a sound device
+ *
+ * @subsection CAPI_MEDIA_SOUND_MANAGER_LIFE_CYCLE_ASYNCHRONOUS_OPERATIONS Asynchronous operations
+ * The Sound Manager API allows only asynchronous operations. \n
+ * Thus the result will be passed to the application via the callback mechanism.
+ * An appropriate callback can be called in response to changes initiated from outside the application. \n
+ * Possible callbacks are listed below:
+ * <p>
+ * <ul>
+ * <li> sound_manager_volume_changed_cb() - invoked when volume level is changed.<p></li>
+ * <li> sound_session_interrupted_cb() - invoked when the session is interrupted.<p></li>
+ * <li> sound_device_connected_cb() - invoked when the connection of a sound device is changed.<p></li>
+ * <li> sound_device_information_changed_cb() - invoked when the information of a sound device is changed.<p></li>
+ * </ul>
+ *
+ * @subsection CAPI_MEDIA_SOUND_MANAGER_MODULE_LIFE_CYCLE_CALLBACK_OPERATIONS Callback(Event) Operations
+ * The callback mechanism is used to notify the application about significant sound manager events.
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b> REGISTER</b></th>
+ * <th><b> UNREGISTER</b></th>
+ * <th><b> CALLBACK</b></th>
+ * <th><b> DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td> sound_manager_set_volume_changed_cb()</td>
+ * <td> sound_manager_unset_volume_changed_cb()</td>
+ * <td> sound_manager_volume_changed_cb()</td>
+ * <td> This callback is called when volume value is changed.</td>
+ * </tr>
+ * <tr>
+ * <td> sound_manager_set_session_interrupted_cb()</td>
+ * <td> sound_manager_unset_session_interrupted_cb()</td>
+ * <td> sound_session_interrupted_cb()</td>
+ * <td> This callback is called when audio session is interrupted.</td>
+ * </tr>
+ * <tr>
+ * <td> sound_manager_set_device_connected_cb()</td>
+ * <td> sound_manager_unset_device_connected_cb()</td>
+ * <td> sound_device_connected_cb()</td>
+ * <td> This callback is called when the connection of a sound device is changed.</td>
+ * </tr>
+ * <tr>
+ * <td> sound_manager_set_device_information_changed_cb()</td>
+ * <td> sound_manager_unset_device_information_changed_cb()</td>
+ * <td> sound_device_information_changed_cb()</td>
+ * <td> This callback is called when the information of a sound device is changed.</td>
+ * </tr>
+ * </table></div>
+ *
+*/
+
+/**
+ * @ingroup CAPI_MEDIA_SOUND_MANAGER_MODULE
+ * @defgroup CAPI_MEDIA_SOUND_MANAGER_VOLUME_MODULE Volume
+ * @brief The @ref CAPI_MEDIA_SOUND_MANAGER_VOLUME_MODULE API provides functions to check and control volumes.
+ * @section CAPI_MEDIA_SOUND_MANAGER_VOLUME_MODULE_HEADER Required Header
+ * \#include <sound_manager.h>
+ *
+ * @section CAPI_MEDIA_SOUND_MANAGER_VOLUME_MODULE_OVERVIEW Overview
+ * The Sound Manager Volume API allows you to:
+ * - check/control output volumes
+ * - handle a volume changed notification
+ *
+ * The Sound Manager has predefined types of sounds.(system, notification, alarm, ringtone, media, call, voip, voice).
+ *
+ * Current volume level of each type can be checked with sound_manager_get_volume().
+ * To get the maximum supported volume level of each type, call sound_manager_get_max_volume().
+ * The volume level of each type can be adjusted with sound_manager_set_volume().
+ *
+ * The type of currently playing sound may be obtained by calling sound_manager_get_current_sound_type().
+ * To set the type of the currently playing sound forcibly, call sound_manager_set_current_sound_type().
+ *
+ *
+*/
+
+/**
+ * @ingroup CAPI_MEDIA_SOUND_MANAGER_MODULE
+ * @defgroup CAPI_MEDIA_SOUND_MANAGER_SESSION_MODULE Session
+ * @brief The @ref CAPI_MEDIA_SOUND_MANAGER_SESSION_MODULE API provides functions to control a session.
+ * @section CAPI_MEDIA_SOUND_MANAGER_SESSION_MODULE_HEADER Required Header
+ * \#include <sound_manager.h>
+ *
+ * @section CAPI_MEDIA_SOUND_MANAGER_SESSION_MODULE_OVERVIEW Overview
+ * The Sound Manager Session API allows you to:
+ * - determine a sound session policy
+ * - handle the notification of a sound session interruption
+ *
+ * The Sound Manager has predefined sound sessions (media, alarm, notification, emergency, voip)
+ *
+ * @section CAPI_MEDIA_SOUND_MANAGER_MODULE_FEATURE Related Features
+ * APIs for voip sound session are related with the following features:\n
+ * - http://tizen.org/feature/microphone\n
+ * - http://tizen.org/feature/sip.voip\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+*/
+
+/**
+ * @ingroup CAPI_MEDIA_SOUND_MANAGER_MODULE
+ * @defgroup CAPI_MEDIA_SOUND_MANAGER_DEVICE_MODULE Device
+ * @brief The @ref CAPI_MEDIA_SOUND_MANAGER_DEVICE_MODULE API provides functions to query the information of sound devices.
+ * @section CAPI_MEDIA_SOUND_MANAGER_DEIVCE_MODULE_HEADER Required Header
+ * \#include <sound_manager.h>
+ *
+ * @section CAPI_MEDIA_SOUND_MANAGER_DEVICE_MODULE_OVERVIEW Overview
+ * The Sound Manager Device API allows you to:
+ * - query the basic information of connected sound devices.
+ * - handle the sound device's connection and information change notification.
+ *
+ * The list of currently connected sound device can be obtained by calling sound_manager_get_current_device_list().
+ * To get the handle of each sound device, call sound_manager_get_next_device() and sound_manager_get_prev_device().
+ *
+ * Device information, such as "type", "IO direction", "state", "ID", "name", can be obtained by calling corresponding APIs.
+ *
+ *
+*/
+
+#endif /* __TIZEN_MEDIA_SOUND_MANAGER_DOC_H__ */
* limitations under the License.
*/
-
-
-
#ifndef __TIZEN_MEDIA_SOUND_MANAGER_H__
#define __TIZEN_MEDIA_SOUND_MANAGER_H__
+#ifndef DEPRECATED
+#define DEPRECATED __attribute__((deprecated))
+#endif
+
#include <tizen.h>
#ifdef __cplusplus
{
#endif
-#define SOUND_MANAGER_ERROR_CLASS TIZEN_ERROR_MULTIMEDIA_CLASS | 0x30
-
/**
* @file sound_manager.h
- * @brief This file contains the Sound Manager API
+ * @brief This file contains the Sound Manager API.
*/
/**
*/
/**
- * @brief Enumerations of sound type
+ * @brief Enumeration for sound manager's error codes.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ SOUND_MANAGER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ SOUND_MANAGER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+ SOUND_MANAGER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ SOUND_MANAGER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
+ SOUND_MANAGER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
+ SOUND_MANAGER_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
+ SOUND_MANAGER_ERROR_NO_DATA = TIZEN_ERROR_NO_DATA, /**< No data */
+ SOUND_MANAGER_ERROR_INTERNAL = TIZEN_ERROR_SOUND_MANAGER | 01, /**< Internal error inside the sound system */
+ SOUND_MANAGER_ERROR_POLICY = TIZEN_ERROR_SOUND_MANAGER | 02, /**< Noncompliance with the sound system policy */
+ SOUND_MANAGER_ERROR_NO_PLAYING_SOUND = TIZEN_ERROR_SOUND_MANAGER | 03, /**< No playing sound */
+} sound_manager_error_e;
+
+/**
+ * @addtogroup CAPI_MEDIA_SOUND_MANAGER_VOLUME_MODULE
+ * @{
+ */
+
+/**
+ * @brief Enumeration for sound type.
+ * @since_tizen 2.3
*/
typedef enum
{
SOUND_TYPE_SYSTEM, /**< Sound type for system */
SOUND_TYPE_NOTIFICATION, /**< Sound type for notifications */
SOUND_TYPE_ALARM, /**< Sound type for alarm */
- SOUND_TYPE_RINGTONE, /**< Sound type for ringtones */
+ SOUND_TYPE_RINGTONE, /**< @internal Sound type for ringtones */
SOUND_TYPE_MEDIA, /**< Sound type for media */
- SOUND_TYPE_CALL, /**< Sound type for call */
+ SOUND_TYPE_CALL, /**< @internal Sound type for call */
+ SOUND_TYPE_VOIP, /**< @internal Sound type for voip */
+ SOUND_TYPE_VOICE, /**< Sound type for voice */
} sound_type_e;
/**
VOLUME_KEY_TYPE_RINGTONE, /**< Volume key type for ringtones sound */
VOLUME_KEY_TYPE_MEDIA, /**< Volume key type for media sound */
VOLUME_KEY_TYPE_CALL, /**< Volume key type for call sound */
-} volume_key_type_e;
+} volume_key_type_e DEPRECATED; // will be deprecated
/**
- * @brief error codes for sound manager
+ * @}
*/
-typedef enum{
- SOUND_MANAGER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
- SOUND_MANAGER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
- SOUND_MANAGER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
- SOUND_MANAGER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
- SOUND_MANAGER_ERROR_NO_PLAYING_SOUND = SOUND_MANAGER_ERROR_CLASS | 01, /**< No playing sound */
-} sound_manager_error_e;
/**
- * @brief Enumerations of session type
+ * @addtogroup CAPI_MEDIA_SOUND_MANAGER_SESSION_MODULE
+ * @{
*/
-typedef enum{
- SOUND_SESSION_TYPE_SHARE = 0, /**< Share type : shares it's session with other share type application. */
- SOUND_SESSION_TYPE_EXCLUSIVE, /**< Exclusive type : make previous session stop.*/
- SOUND_SESSION_TYPE_ALARM, /**< Alarm type */
- SOUND_SESSION_TYPE_EMERGENCY, /**< Emergency type */
+
+/**
+ * @brief Enumeration for session type.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ SOUND_SESSION_TYPE_MEDIA = 0, /**< Media type */
+ SOUND_SESSION_TYPE_ALARM, /**< Alarm type */
+ SOUND_SESSION_TYPE_NOTIFICATION, /**< Notification type */
+ SOUND_SESSION_TYPE_EMERGENCY, /**< Emergency type */
+ SOUND_SESSION_TYPE_VOIP, /**< VOIP type */
+ SOUND_SESSION_TYPE_SHARE = SOUND_SESSION_TYPE_MEDIA, /**< will be deprecated */
+ SOUND_SESSION_TYPE_EXCLUSIVE = SOUND_SESSION_TYPE_MEDIA, /**< will be deprecated */
} sound_session_type_e;
/**
+ * @brief Enumeration for session option for starting.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ SOUND_SESSION_OPTION_MIX_WITH_OTHERS_WHEN_START = 0, /**< This session will be mixed with others when starting (default) */
+ SOUND_SESSION_OPTION_PAUSE_OTHERS_WHEN_START, /**< This session will interrupt other sessions when starting */
+} sound_session_option_for_starting_e;
+
+/**
+ * @brief Enumeration for session option during play.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ SOUND_SESSION_OPTION_INTERRUPTIBLE_DURING_PLAY = 0, /**< This session will be interrupted by other sessions during play (default) */
+ SOUND_SESSION_OPTION_UNINTERRUPTIBLE_DURING_PLAY, /**< This session will not be interrupted by other media sessions */
+} sound_session_option_for_during_play_e;
+
+/**
+ * @brief Enumeration for session option for resumption.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM = 0, /**< This session will be resumed according to system policy (default) */
+ SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM_OR_MEDIA_PAUSED, /**< This session will be resumed according to system policy and when the media session which interrupted this session is paused */
+} sound_session_option_for_resumption_e;
+
+/**
+ * @brief Enumeration for voip session mode.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ SOUND_SESSION_VOIP_MODE_RINGTONE = 0, /**< voip mode for ringtone */
+ SOUND_SESSION_VOIP_MODE_VOICE_WITH_BUILTIN_RECEIVER, /**< voip mode for during call with built-in receiver */
+ SOUND_SESSION_VOIP_MODE_VOICE_WITH_BUILTIN_SPEAKER, /**< voip mode for during call with built-in speaker */
+ SOUND_SESSION_VOIP_MODE_VOICE_WITH_AUDIO_JACK, /**< voip mode for during call with audio jack */
+ SOUND_SESSION_VOIP_MODE_VOICE_WITH_BLUETOOTH, /**< voip mode for during call with bluetooth */
+} sound_session_voip_mode_e;
+
+/**
+ * @brief Enumeration for sound session interrupted type.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ SOUND_SESSION_INTERRUPTED_COMPLETED = 0, /**< Interrupt completed*/
+ SOUND_SESSION_INTERRUPTED_BY_MEDIA, /**< Interrupted by media application*/
+ SOUND_SESSION_INTERRUPTED_BY_CALL, /**< Interrupted by an incoming call*/
+ SOUND_SESSION_INTERRUPTED_BY_EARJACK_UNPLUG, /**< Interrupted by unplugging headphones*/
+ SOUND_SESSION_INTERRUPTED_BY_RESOURCE_CONFLICT, /**< Interrupted by a resource conflict*/
+ SOUND_SESSION_INTERRUPTED_BY_ALARM, /**< Interrupted by an alarm*/
+ SOUND_SESSION_INTERRUPTED_BY_EMERGENCY, /**< Interrupted by an emergency*/
+ SOUND_SESSION_INTERRUPTED_BY_NOTIFICATION, /**< Interrupted by a notification*/
+} sound_session_interrupted_code_e;
+
+/**
+ * @brief Called when the playing sound session is interrupted.
+ * @since_tizen 2.3
+ * @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 using sound_manager_set_session_interrupted_cb().
+ * @see sound_manager_set_session_interrupted_cb()
+ * @see sound_manager_unset_session_interrupted_cb()
+ */
+typedef void(* sound_session_interrupted_cb)(sound_session_interrupted_code_e code, void *user_data);
+
+
+
+/**
* @brief Enumerations of session notification
*/
typedef enum{
SOUND_SESSION_NOTIFY_STOP = 0, /**< Stop : session of application has interrupted by policy. */
SOUND_SESSION_NOTIFY_RESUME, /**< Resume : session interrupt of application has ended. */
-} sound_session_notify_e;
+} sound_session_notify_e DEPRECATED; // will be deprecated
+
+/**
+ * @brief Enumerations of sound interrupted type
+ */
+typedef enum
+{
+ SOUND_INTERRUPTED_COMPLETED = 0, /**< Interrupt completed*/
+ SOUND_INTERRUPTED_BY_MEDIA, /**< Interrupted by non-resumable media 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_BY_EMERGENCY, /**< Interrupted by emergency*/
+ SOUND_INTERRUPTED_BY_RESUMABLE_MEDIA, /**< Interrupted by resumable media application*/
+} sound_interrupted_code_e DEPRECATED; // will be deprecated
+
+/**
+ * @brief Called when the sound session notification has occured.
+ * @param[in] notify The sound session notification
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre You should register this callback by sound_manager_set_session_notify_cb()
+ * @see sound_manager_set_session_notify_cb()
+ */
+typedef void (*sound_session_notify_cb) (sound_session_notify_e notify, void *user_data) DEPRECATED; // will be deprecated
+
+/**
+ * @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) DEPRECATED; // will be deprecated
+
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_SOUND_MANAGER_DEVICE_MODULE
+ * @{
+ */
+
+/**
+ * @brief sound device handle
+ * @since_tizen 2.3
+ */
+typedef void* sound_device_h;
+
+/**
+ * @brief sound device list handle
+ * @since_tizen 2.3
+ */
+typedef void* sound_device_list_h;
+
+/**
+* @brief Enumeration for sound device type.
+* @since_tizen 2.3
+*/
+typedef enum{
+ SOUND_DEVICE_BUILTIN_SPEAKER, /**< Built-in speaker */
+ SOUND_DEVICE_BUILTIN_RECEIVER, /**< Built-in receiver */
+ SOUND_DEVICE_BUILTIN_MIC, /**< Built-in mic */
+ SOUND_DEVICE_AUDIO_JACK, /**< Audio jack that can be connected to wired accessory such as headphone, headset, and so on */
+ SOUND_DEVICE_BLUETOOTH, /**< Bluetooth */
+ SOUND_DEVICE_HDMI, /**< HDMI */
+ SOUND_DEVICE_MIRRORING, /**< MIRRORING */
+ SOUND_DEVICE_USB_AUDIO, /**< USB Audio */
+} sound_device_type_e;
+
+/**
+* @brief Enumeration for sound device direction.
+* @since_tizen 2.3
+*/
+typedef enum {
+ SOUND_DEVICE_IO_DIRECTION_IN, /**< Input device */
+ SOUND_DEVICE_IO_DIRECTION_OUT, /**< Output device */
+ SOUND_DEVICE_IO_DIRECTION_BOTH, /**< Input/output device (both directions are available) */
+} sound_device_io_direction_e;
+
+/**
+* @brief Enumeration for sound device state.
+* @since_tizen 2.3
+*/
+typedef enum {
+ SOUND_DEVICE_STATE_DEACTIVATED, /**< Deactivated state */
+ SOUND_DEVICE_STATE_ACTIVATED, /**< Activated state */
+} sound_device_state_e;
+
+/**
+* @brief Enumeration for sound device mask.
+* @since_tizen 2.3
+*/
+typedef enum {
+ SOUND_DEVICE_IO_DIRECTION_IN_MASK = 0x0001, /**< Mask for input devices */
+ SOUND_DEVICE_IO_DIRECTION_OUT_MASK = 0x0002, /**< Mask for output devices */
+ SOUND_DEVICE_IO_DIRECTION_BOTH_MASK = 0x0004, /**< Mask for input/output devices (both directions are available) */
+ SOUND_DEVICE_TYPE_INTERNAL_MASK = 0x0010, /**< Mask for built-in devices */
+ SOUND_DEVICE_TYPE_EXTERNAL_MASK = 0x0020, /**< Mask for external devices */
+ SOUND_DEVICE_STATE_DEACTIVATED_MASK = 0x1000, /**< Mask for deactivated devices */
+ SOUND_DEVICE_STATE_ACTIVATED_MASK = 0x2000, /**< Mask for activated devices */
+ SOUND_DEVICE_ALL_MASK = 0xFFFF, /**< Mask for all devices */
+} sound_device_mask_e;
+
+/**
+* @brief Enumeration for changed information of sound device.
+* @since_tizen 2.3
+*/
+typedef enum {
+ SOUND_DEVICE_CAHNGED_INFO_STATE, /**< State of the device was changed */
+ SOUND_DEVICE_CHANGED_INFO_IO_DIRECTION, /**< IO direction of the device was changed */
+} sound_device_changed_info_e;
+
+/**
+ * @brief Called when the state of connection of a sound device was changed.
+ * @since_tizen 2.3
+ * @param[in] sound_device_h The sound_device
+ * @param[in] is_connected The state of device connection
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre You should register this callback using sound_manager_set_device_connected_cb().
+ * @see sound_manager_set_device_connected_cb()
+ * @see sound_manager_unset_device_connected_cb()
+ */
+typedef void(* sound_device_connected_cb)(sound_device_h device, bool is_connected, void *user_data);
+
+/**
+ * @brief Called when the information of a sound device was changed.
+ * @since_tizen 2.3
+ * @param[in] sound_device_h The sound_device
+ * @param[in] changed_info The entry of sound device information
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre You should register this callback using sound_manager_set_device_information_changed_cb().
+ * @see sound_manager_set_device_information_changed_cb()
+ * @see sound_manager_unset_device_information_changed_cb()
+ */
+typedef void(* sound_device_information_changed_cb)(sound_device_h device, sound_device_changed_info_e changed_info, void *user_data);
+
+
/**
* @brief Enumerations of audio input device type.
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;
+} sound_device_in_e DEPRECATED;// will be deprecated
/**
* @brief Enumerations of audio output device type.
SOUND_DEVICE_OUT_HDMI = 0x040<<8, /**< HDMI device */
SOUND_DEVICE_OUT_WFD = 0x080<<8, /**< WFD device */
SOUND_DEVICE_OUT_USB_AUDIO = 0x100<<8, /**< USB Audio device */
-} sound_device_out_e;
+} sound_device_out_e DEPRECATED;// will be deprecated
/**
* @brief Enumerations of route type.
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_CALL_SESSION_TYPE_CALL = 0, /**< call type */
- SOUND_CALL_SESSION_TYPE_VOIP = 1, /**< voip type */
- SOUND_SESSION_TYPE_CALL = 0,
- SOUND_SESSION_TYPE_VOIP = 1,
-} sound_call_session_type_e;
-
-/**
- * @brief Enumerations of communication session type
- */
-typedef enum{
- SOUND_CALL_SESSION_MODE_VOICE = 0, /**< normal talking mode */
- SOUND_CALL_SESSION_MODE_RINGTONE, /**< ringtone mode */
- SOUND_CALL_SESSION_MODE_MEDIA, /**< notification sound in call*/
-} sound_call_session_mode_e;
-
-/**
- * @brief Enumerations of sound interrupted type
- */
-typedef enum
-{
- SOUND_INTERRUPTED_COMPLETED = 0, /**< Interrupt completed*/
- SOUND_INTERRUPTED_BY_MEDIA, /**< Interrupted by non-resumable media 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_BY_EMERGENCY, /**< Interrupted by emergency*/
- SOUND_INTERRUPTED_BY_RESUMABLE_MEDIA, /**< Interrupted by resumable media application*/
-} sound_interrupted_code_e;
+} sound_route_e DEPRECATED;// will be deprecated
/**
- * @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.
- * @param[in] notify The sound session notification
- * @param[in] user_data The user data passed from the callback registration function
- * @pre You should register this callback by sound_manager_set_session_notify_cb()
- * @see sound_manager_set_session_notify_cb()
- */
-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()
+ * @addtogroup CAPI_MEDIA_SOUND_MANAGER_VOLUME_MODULE
+ * @{
*/
-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
+ * @since_tizen 2.3
+ * @param[in] type The sound type of the changed volume
* @param[in] volume The new volume value
* @param[in] user_data The user data passed from the callback registration function
- * @pre sound_manager_set_volume() will invoke this callback if you register it using sound_manager_set_volume_changed_cb()
+ * @pre sound_manager_set_volume() will invoke this callback if you register it using sound_manager_set_volume_changed_cb().
* @see sound_manager_set_volume_changed_cb()
* @see sound_manager_unset_volume_changed_cb()
*/
typedef void (*sound_manager_volume_changed_cb)(sound_type_e type, unsigned int volume, void *user_data);
/**
- * @brief Gets the maximum volume level supported for a particular sound type
+ * @brief Gets the maximum volume level supported for a particular sound type.
+ * @since_tizen 2.3
* @param[in] type The sound type
* @param[out] max The maximum volume level
- * @return 0 on success, otherwise a negative error value.
+ * @return @c 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_volume()
+ * @see sound_manager_get_volume()
*/
int sound_manager_get_max_volume(sound_type_e type, int *max);
/**
- * @brief Sets the volume level specified for a particular sound type
+ * @brief Sets the volume level specified for a particular sound type.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/volume.set
* @param[in] type The sound type
- * @param[out] volume The volume level to be set
- * @return 0 on success, otherwise a negative error value.
+ * @param[in] volume The volume level to be set
+ * @return @c 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_PERMISSION_DENIED Permission denied
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
* @see sound_manager_get_max_volume()
* @see sound_manager_get_volume()
*/
int sound_manager_set_volume(sound_type_e type, int volume);
/**
- * @brief Gets the volume level specified for a particular sound type
+ * @brief Gets the volume level specified for a particular sound type.
+ * @since_tizen 2.3
* @param[in] type The sound type
* @param[out] volume The current volume level
- * @return 0 on success, otherwise a negative error value.
+ * @return @c 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_INTERNAL Internal error inside the sound system
* @see sound_manager_get_max_volume()
* @see sound_manager_set_volume()
*/
int sound_manager_get_volume(sound_type_e type, int *volume);
/**
- * @brief Gets the current playing sound type
- * @param[out] type The current sound type
- * @return 0 on success, otherwise a negative error value.
+ * @brief Sets the type of the sound being currently played.
+ * @since_tizen 2.3
+ * @param[in] type The sound type to set
+ * @return @c 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_INTERNAL Internal error inside the sound system
+ * @see sound_manager_get_current_sound_type()
+ * @see sound_manager_unset_current_sound_type()
+ */
+int sound_manager_set_current_sound_type(sound_type_e type);
+
+/**
+ * @brief Gets the type of the sound being currently played.
+ * @since_tizen 2.3
+ * @param[out] type The current sound type
+ * @return @c 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
- * @see player_set_sound_type()
- * @see audio_out_create()
- * @see wav_player_start()
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @see sound_manager_set_current_sound_type()
+ * @see sound_manager_unset_current_sound_type()
*/
int sound_manager_get_current_sound_type(sound_type_e *type);
/**
+ * @brief Unsets the type of the sound being currently played.
+ * @since_tizen 2.3
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @see sound_manager_set_current_sound_type()
+ * @see sound_manager_get_current_sound_type()
+ */
+int sound_manager_unset_current_sound_type(void);
+
+/**
* @brief Registers a callback function to be invoked when the volume level is changed.
+ * @since_tizen 2.3
* @param[in] callback Callback function to indicate change in volume
* @param[in] user_data The user data to be passed to the callback function
- * @return 0 on success, otherwise a negative error value.
+ * @return @c 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_volume_changed_cb() will be invoked
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @post sound_manager_volume_changed_cb() will be invoked.
* @see sound_manager_unset_volume_changed_cb()
* @see sound_manager_volume_changed_cb()
*/
int sound_manager_set_volume_changed_cb(sound_manager_volume_changed_cb callback, void *user_data);
/**
- * @brief Unregisters the volume change callback
+ * @brief Unregisters the volume change callback.
+ * @since_tizen 2.3
+ * @return 0 on success, otherwise a negative error value
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
* @see sound_manager_set_volume_changed_cb()
*/
-void sound_manager_unset_volume_changed_cb(void);
+int sound_manager_unset_volume_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)
- * @param[out] bt_name The Bluetooth A2DP connected device name
+ * @brief Sets the volume key type
+ * @param[in] type The volume key type 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
- * @retval #SOUND_MANAGER_ERROR_INVALID_OPERATION Invalid operation
*/
-int sound_manager_get_a2dp_status(bool *connected, char **bt_name);
+int sound_manager_set_volume_key_type(volume_key_type_e type) DEPRECATED;// will be deprecated
+/**
+ * @}
+ */
/**
- * @brief Sets the application's sound session type
+ * @addtogroup CAPI_MEDIA_SOUND_MANAGER_SESSION_MODULE
+ * @{
+ */
+
+/**
+ * @brief Sets the application's sound session type.
+ * @since_tizen 2.3
* @param[in] type The session type to set
- * @return 0 on success, otherwise a negative error value.
+ * @return @c 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_NOT_SUPPORTED Not supported
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @retval #SOUND_MANAGER_ERROR_POLICY Noncompliance with the sound system policy
+ * @see sound_manager_get_session_type()
+ * @see sound_manager_set_media_session_option()
+ * @see sound_manager_get_media_session_option()
+ * @see sound_manager_set_media_session_resumption_option()
+ * @see sound_manager_get_media_session_resumption_option()
+ * @see sound_manager_set_voip_session_mode()
+ * @see sound_manager_get_voip_session_mode()
*/
int sound_manager_set_session_type(sound_session_type_e type);
-
/**
- * @brief Gets the application's sound session type
+ * @brief Gets the application's sound session type.
+ * @since_tizen 2.3
* @param[in] type The session type
- * @return 0 on success, otherwise a negative error value.
+ * @return @c 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_session_type()
+ * @see sound_manager_set_media_session_option()
+ * @see sound_manager_get_media_session_option()
+ * @see sound_manager_set_media_session_resumption_option()
+ * @see sound_manager_get_media_session_resumption_option()
+ * @see sound_manager_set_voip_session_mode()
+ * @see sound_manager_get_voip_session_mode()
*/
int sound_manager_get_session_type(sound_session_type_e *type);
+/**
+ * @brief Sets the media sound session option.
+ * @since_tizen 2.3
+ * @param[in] s_option The session option for starting
+ * @param[in] d_option The session option for during play
+ * @return @c 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_INVALID_OPERATION Invalid operation
+ * @retval #SOUND_MANAGER_ERROR_POLICY Noncompliance with the sound system policy
+ * @pre Call sound_manager_set_session_type(SOUND_SESSION_TYPE_MEDIA) before calling this function.
+ * @see sound_manager_set_session_type()
+ * @see sound_manager_get_session_type()
+ * @see sound_manager_get_media_session_option()
+ * @see sound_manager_set_media_session_resumption_option()
+ * @see sound_manager_get_media_session_resumption_option()
+ */
+int sound_manager_set_media_session_option(sound_session_option_for_starting_e s_option, sound_session_option_for_during_play_e d_option);
+
+/**
+ * @brief Gets the media sound session option.
+ * @since_tizen 2.3
+ * @param[out] s_option The session option for starting
+ * @param[out] d_option The session option for during play
+ * @return @c 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_INVALID_OPERATION Invalid operation
+ * @retval #SOUND_MANAGER_ERROR_POLICY Noncompliance with the sound system policy
+ * @see sound_manager_set_session_type()
+ * @see sound_manager_get_session_type()
+ * @see sound_manager_set_media_session_option()
+ * @see sound_manager_set_media_session_resumption_option()
+ * @see sound_manager_get_media_session_resumption_option()
+ */
+int sound_manager_get_media_session_option(sound_session_option_for_starting_e *s_option, sound_session_option_for_during_play_e *d_option);
+
+/**
+ * @brief Sets the media sound session resumption option.
+ * @since_tizen 2.3
+ * @param[in] option The session resumption option
+ * @return @c 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_INVALID_OPERATION Invalid operation
+ * @retval #SOUND_MANAGER_ERROR_POLICY Noncompliance with the sound system policy
+ * @pre Call sound_manager_set_session_type(SOUND_SESSION_TYPE_MEDIA) before calling this function.
+ * @see sound_manager_set_session_type()
+ * @see sound_manager_get_session_type()
+ * @see sound_manager_set_media_session_option()
+ * @see sound_manager_get_media_session_option()
+ * @see sound_manager_get_media_session_resumption_option()
+ */
+int sound_manager_set_media_session_resumption_option(sound_session_option_for_resumption_e option);
+
+/**
+ * @brief Gets the media sound session resumption option.
+ * @since_tizen 2.3
+ * @param[out] option The session resumption option
+ * @return @c 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_INVALID_OPERATION Invalid operation
+ * @retval #SOUND_MANAGER_ERROR_POLICY Noncompliance with the sound system policy
+ * @see sound_manager_set_session_type()
+ * @see sound_manager_get_session_type()
+ * @see sound_manager_set_media_session_option()
+ * @see sound_manager_get_media_session_option()
+ * @see sound_manager_set_media_session_resumption_option()
+ */
+int sound_manager_get_media_session_resumption_option(sound_session_option_for_resumption_e *option);
+
+/**
+ * @brief Sets the mode of the voip sound session.
+ * @since_tizen 2.3
+ * @param[in] mode The voip session mode
+ * @return @c 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_NOT_SUPPORTED Not supported
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @retval #SOUND_MANAGER_ERROR_POLICY Noncompliance with the sound system policy
+ * @pre Call sound_manager_set_session_type(SOUND_SESSION_TYPE_VOIP) before calling this function.
+ * @see sound_manager_set_session_type()
+ * @see sound_manager_get_session_type()
+ * @see sound_manager_get_voip_session_mode()
+*/
+int sound_manager_set_voip_session_mode(sound_session_voip_mode_e mode);
+
+/**
+ * @brief Gets the mode of the voip sound session.
+ * @since_tizen 2.3
+ * @param[out] mode The voip session mode
+ * @return @c 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_NOT_SUPPORTED Not supported
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @retval #SOUND_MANAGER_ERROR_POLICY Noncompliance with the sound system policy
+ * @pre Call sound_manager_set_session_type(SOUND_SESSION_TYPE_VOIP) before calling this function.
+ * @see sound_manager_set_session_type()
+ * @see sound_manager_get_session_type()
+ * @see sound_manager_set_voip_session_mode()
+*/
+int sound_manager_get_voip_session_mode(sound_session_voip_mode_e *mode);
+
+/**
+ * @brief Registers a callback function to be invoked when the sound session being played was interrupted.
+ * @since_tizen 2.3
+ * @param[in] callback The interrupted callback function
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 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_POLICY Noncompliance with the sound system policy
+ * @post sound_session_interrupted_cb() will be invoked.
+ * @see sound_manager_unset_session_interrupted_cb()
+ * @see sound_session_interrupted_cb()
+ */
+int sound_manager_set_session_interrupted_cb(sound_session_interrupted_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function which is called when the sound session being played is interrupted.
+ * @since_tizen 2.3
+ * @return 0 on success,
+ * otherwise a negative error value
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @see sound_manager_set_session_interrupted_cb()
+ */
+int sound_manager_unset_session_interrupted_cb(void);
/**
* @brief Registers a callback function to be invoked when the sound session notification is occured.
* @see sound_manager_unset_session_notify_cb()
* @see sound_session_notify_cb()
*/
-int sound_manager_set_session_notify_cb(sound_session_notify_cb callback, void *user_data);
+int sound_manager_set_session_notify_cb(sound_session_notify_cb callback, void *user_data) DEPRECATED;// will be deprecated
/**
* @brief Unregisters the callback function which is called when the session notification is occured
* @see sound_manager_set_session_notify_cb()
*/
-void sound_manager_unset_session_notify_cb(void);
+void sound_manager_unset_session_notify_cb(void) DEPRECATED;// will be deprecated;
/**
* @brief Registers a callback function to be invoked when the playing sound was interrupted.
* @see sound_manager_unset_interrupted_cb()
* @see sound_interrupted_cb()
*/
-int sound_manager_set_interrupted_cb(sound_interrupted_cb callback, void *user_data);
+int sound_manager_set_interrupted_cb(sound_interrupted_cb callback, void *user_data) DEPRECATED;// will be deprecated;
/**
* @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);
+void sound_manager_unset_interrupted_cb(void) DEPRECATED;// will be deprecated;
+/**
+ * @}
+ */
+/**
+ * @addtogroup CAPI_MEDIA_SOUND_MANAGER_DEVICE_MODULE
+ * @{
+ */
/**
- * @brief Sets the volume key type
- * @param[in] type The volume key type to set
- * @return 0 on success, otherwise a negative error value.
+ * @brief Gets the list consisting of connected devices.
+ * @since_tizen 2.3
+ * @param[in] device_mask The mask value
+ * @param[out] device_list The list of connected devices
+ *
+ * @remarks @a Use sound_manager_get_next_device() to get the first node of the list.
+ *
+ * @return @c 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_DATA No data
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @see sound_manager_get_next_device()
+ * @see sound_manager_get_prev_device()
+ * @see sound_manager_get_device_type()
+ * @see sound_manager_get_device_io_direction()
+ * @see sound_manager_get_device_id()
+ * @see sound_manager_get_device_name()
+ * @see sound_manager_get_device_state()
+ */
+int sound_manager_get_current_device_list(sound_device_mask_e device_mask, sound_device_list_h *device_list);
+
+/**
+ * @brief Gets the next item of the device list.
+ * @since_tizen 2.3
+ * @param[in] device_list The list of connected devices
+ * @param[out] device The device item
+ * @return @c 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_DATA No data
+ * @see sound_manager_get_current_device_list()
+ * @see sound_manager_get_prev_device()
+ * @see sound_manager_get_device_type()
+ * @see sound_manager_get_device_io_direction()
+ * @see sound_manager_get_device_id()
+ * @see sound_manager_get_device_name()
+ * @see sound_manager_get_device_state()
+ */
+int sound_manager_get_next_device (sound_device_list_h device_list, sound_device_h *device);
+
+/**
+ * @brief Gets the previous item of the device list.
+ * @since_tizen 2.3
+ * @param[in] device_list The list of connected devices
+ * @param[out] device The device item
+ * @return @c 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_DATA No data
+ * @see sound_manager_get_current_device_list()
+ * @see sound_manager_get_next_device()
+ * @see sound_manager_get_device_type()
+ * @see sound_manager_get_device_io_direction()
+ * @see sound_manager_get_device_id()
+ * @see sound_manager_get_device_name()
+ * @see sound_manager_get_device_state()
*/
-int sound_manager_set_volume_key_type(volume_key_type_e type);
+int sound_manager_get_prev_device (sound_device_list_h device_list, sound_device_h *device);
+
+/**
+ * @brief Gets the type of the device.
+ * @since_tizen 2.3
+ * @param[in] device The device item
+ * @param[out] type The type of the device
+ * @return @c 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_current_device_list()
+ * @see sound_manager_get_next_device()
+ * @see sound_manager_get_prev_device()
+ * @see sound_manager_get_device_io_direction()
+ * @see sound_manager_get_device_id()
+ * @see sound_manager_get_device_name()
+ * @see sound_manager_get_device_state()
+ */
+int sound_manager_get_device_type (sound_device_h device, sound_device_type_e *type);
+
+/**
+ * @brief Gets the io direction of the device.
+ * @since_tizen 2.3
+ * @param[in] device The device item
+ * @param[out] io_direction The io direction of the device
+ * @return @c 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_current_device_list()
+ * @see sound_manager_get_next_device()
+ * @see sound_manager_get_prev_device()
+ * @see sound_manager_get_device_type()
+ * @see sound_manager_get_device_id()
+ * @see sound_manager_get_device_name()
+ * @see sound_manager_get_device_state()
+ */
+int sound_manager_get_device_io_direction (sound_device_h device, sound_device_io_direction_e *io_direction);
+
+/**
+ * @brief Gets the id of the device.
+ * @since_tizen 2.3
+ * @param[in] device The device item
+ * @param[out] id The id of the device
+ * @return @c 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_current_device_list()
+ * @see sound_manager_get_next_device()
+ * @see sound_manager_get_prev_device()
+ * @see sound_manager_get_device_type()
+ * @see sound_manager_get_device_io_direction()
+ * @see sound_manager_get_device_name()
+ * @see sound_manager_get_device_state()
+ */
+int sound_manager_get_device_id (sound_device_h device, int *id);
+
+/**
+ * @brief Gets the name of the device.
+ * @since_tizen 2.3
+ * @param[in] device The device item
+ * @param[out] name The name of the device
+ * @return @c 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_INTERNAL Internal error inside the sound system
+ * @see sound_manager_get_current_device_list()
+ * @see sound_manager_get_next_device()
+ * @see sound_manager_get_prev_device()
+ * @see sound_manager_get_device_type()
+ * @see sound_manager_get_device_io_direction()
+ * @see sound_manager_get_device_id()
+ * @see sound_manager_get_device_state()
+ */
+int sound_manager_get_device_name (sound_device_h device, char **name);
+
+/**
+ * @brief Gets the state of the device.
+ * @since_tizen 2.3
+ * @param[in] device The device item
+ * @param[out] state The state of the device
+ * @return @c 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_current_device_list()
+ * @see sound_manager_get_next_device()
+ * @see sound_manager_get_prev_device()
+ * @see sound_manager_get_device_type()
+ * @see sound_manager_get_device_io_direction()
+ * @see sound_manager_get_device_id()
+ * @see sound_manager_get_device_name()
+ */
+int sound_manager_get_device_state (sound_device_h device, sound_device_state_e *state);
+
+/**
+ * @brief Registers a callback function to be invoked when the state of connection of a sound device was changed.
+ * @since_tizen 2.3
+ * @param[in] device_mask The mask value
+ * @param[in] callback The interrupted callback function
+ * @param[in] user_data The user data to be passed to the callback function
+ *
+ * @remarks @a The initial state of sound devices connected is deactivated.
+ *
+ * @return @c 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_INTERNAL Internal error inside the sound system
+ * @post sound_device_connected_cb() will be invoked.
+ * @see sound_manager_unset_device_connected_cb()
+ * @see sound_device_connected_cb()
+ */
+int sound_manager_set_device_connected_cb (sound_device_mask_e device_mask, sound_device_connected_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function which is called when the state of connection of a sound device was changed.
+ * @since_tizen 2.3
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @see sound_manager_set_device_connected_cb()
+ */
+int sound_manager_unset_device_connected_cb (void);
+
+/**
+ * @brief Registers a callback function to be invoked when the information of a sound device was changed.
+ * @since_tizen 2.3
+ * @param[in] device_mask The mask value
+ * @param[in] callback The interrupted callback function
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 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_INTERNAL Internal error inside the sound system
+ * @post sound_device_information_changed_cb() will be invoked.
+ * @see sound_manager_unset_device_information_changed_cb()
+ * @see sound_device_information_changed_cb()
+ */
+int sound_manager_set_device_information_changed_cb (sound_device_mask_e device_mask, sound_device_information_changed_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function which is called when the information of a sound device was changed.
+ * @since_tizen 2.3
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
+ * @retval #SOUND_MANAGER_ERROR_INTERNAL Internal error inside the sound system
+ * @see sound_manager_set_device_information_changed_cb()
+ */
+int sound_manager_unset_device_information_changed_cb (void);
+
+
/**
* @brief Gets called iteratively to notify you of available route.
* @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);
+typedef bool(* sound_available_route_cb)(sound_route_e route, void *user_data) DEPRECATED;// will be deprecated
/**
* @brief Called when the available audio route is changed.
* @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);
+typedef void(* sound_available_route_changed_cb)(sound_route_e route, bool available, void *user_data) DEPRECATED;// will be deprecated
/**
* @brief Called when the audio route is changed.
* @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);
+typedef void(* sound_active_device_changed_cb)(sound_device_in_e in, sound_device_out_e out, void *user_data) DEPRECATED;// will be deprecated
/**
* @brief Retrieves all available audio routes by invoking a specific callback for each valid route.
* @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);
+int sound_manager_foreach_available_route (sound_available_route_cb callback, void *user_data) DEPRECATED;// will be deprecated
/**
* @brief Changes the audio routes.
* @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
* @see sound_manager_get_active_device()
*/
-int sound_manager_set_active_route (sound_route_e route);
+int sound_manager_set_active_route (sound_route_e route) DEPRECATED;// will be deprecated
/**
* @brief Changes the audio route.
* @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);
+int sound_manager_get_active_device (sound_device_in_e *in, sound_device_out_e *out) DEPRECATED;// will be deprecated
/**
* @brief Check if given audio route is available or not.
* @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);
+bool sound_manager_is_route_available (sound_route_e route) DEPRECATED;// will be deprecated
/**
* @brief Registers a callback function to be invoked when the available status is changed.
* @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);
+int sound_manager_set_available_route_changed_cb (sound_available_route_changed_cb callback, void *user_data) DEPRECATED;// will be deprecated
/**
* @brief Unregisters the callback function.
* @see sound_manager_set_available_route_changed_cb()
*/
-void sound_manager_unset_available_route_changed_cb (void);
+void sound_manager_unset_available_route_changed_cb (void) DEPRECATED;// will be deprecated
/**
* @brief Registers a callback function to be invoked when the audio device is changed.
* @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);
+void sound_manager_unset_active_device_changed_cb (void) DEPRECATED;// will be deprecated
-/**
- * @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
+ * @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)
+ * @param[out] bt_name The Bluetooth A2DP connected device name
* @return 0 on success, otherwise a negative error value.
- * @retval #SOUND_MANAGER_ERROR_NONE Successful
+ * @retval #SOUND_MANAGER_ERROR_NONE Success
* @retval #SOUND_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter
- * @see sound_manager_call_session_set_mode()
+ * @retval #SOUND_MANAGER_ERROR_INVALID_OPERATION Invalid operation
*/
-int sound_manager_call_session_get_mode(sound_call_session_h session, sound_call_session_mode_e *mode);
+int sound_manager_get_a2dp_status(bool *connected, char **bt_name) DEPRECATED;// will be deprecated
/**
- * @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);
/**
* @}
--- /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.
+*/
+
+#ifndef __TIZEN_MEDIA_SOUND_MANAGER_INTERNAL_H__
+#define __TIZEN_MEDIA_SOUND_MANAGER_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define SOUND_TYPE_NUM SOUND_TYPE_VOICE + 1
+
+/**
+ * @file sound_manager_internal.h
+ * @brief This file contains the Sound Manager API (internal header)
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_MEDIA_SOUND_MANAGER_INTERNAL_H__ */
--- /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.
+*/
+
+#ifndef __TIZEN_MEDIA_SOUND_MANAGER_PRIVATE_H__
+#define __TIZEN_MEDIA_SOUND_MANAGER_PRIVATE_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#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>
+#include <mm_sound.h>
+#include <mm_sound_private.h>
+#include "sound_manager_internal.h"
+
+#define SOUND_SESSION_TYPE_DEFAULT SOUND_SESSION_TYPE_MEDIA
+
+typedef struct {
+ int is_registered;
+ void *user_data;
+ sound_session_interrupted_cb user_cb;
+}_session_interrupt_info_s;
+
+typedef struct {
+ void *user_data;
+ sound_manager_volume_changed_cb user_cb;
+}_volume_changed_info_s;
+
+typedef struct {
+ void *user_data;
+ sound_device_connected_cb user_cb;
+}_device_connected_info_s;
+
+typedef struct {
+ void *user_data;
+ sound_device_information_changed_cb user_cb;
+}_device_changed_info_s;
+
+int __convert_sound_manager_error_code(const char *func, int code);
+
+void __session_interrupt_cb(session_msg_t msg, session_event_t event, void *user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_MEDIA_SOUND_MANAGER_PRIVATE_H__ */
Name: capi-media-sound-manager
Summary: Sound Manager library
-Version: 0.1.1
+Version: 0.2.27
Release: 0
Group: Multimedia/API
License: Apache-2.0
BuildRequires: pkgconfig(mm-sound)
BuildRequires: pkgconfig(mm-session)
BuildRequires: pkgconfig(capi-base-common)
+BuildRequires: pkgconfig(vconf)
+Requires(post): /sbin/ldconfig
+Requires(postun): /sbin/ldconfig
+Requires(post): libprivilege-control
+
%description
A Sound Manager library in Tizen C API
%__make %{?jobs:-j%jobs}
%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}/usr/share/license
+mkdir -p %{buildroot}/opt/usr/devel
+cp LICENSE %{buildroot}/usr/share/license/%{name}
+cp test/sound_manager_test %{buildroot}/opt/usr/devel
+
%make_install
-%post -p /sbin/ldconfig
+%post
+/sbin/ldconfig
+/usr/bin/api_feature_loader --verbose --dir=/usr/share/privilege-control
%postun -p /sbin/ldconfig
%files
%manifest %{name}.manifest
-%license LICENSE.APLv2
%{_libdir}/libcapi-media-sound-manager.so.*
+%{_datadir}/license/%{name}
+/opt/usr/devel/*
%files devel
%manifest %{name}.manifest
%{_includedir}/media/sound_manager.h
+%{_includedir}/media/sound_manager_internal.h
%{_libdir}/pkgconfig/*.pc
%{_libdir}/libcapi-media-sound-manager.so
*/
-#define LOG_TAG "TIZEN_N_SOUND_MANGER"
+#define LOG_TAG "TIZEN_N_SOUND_MANAGER"
#include <sound_manager.h>
-#include <mm_sound.h>
-#include <mm_sound_private.h>
-#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
+#include <sound_manager_private.h>
typedef struct {
void *user_data;
sound_manager_volume_changed_cb user_cb;
}_changed_volume_info_s;
-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;
+_session_interrupt_info_s g_session_interrupt_cb_table = {0, NULL, NULL};
+_volume_changed_info_s g_volume_changed_cb_table = {NULL, NULL};
+_device_connected_info_s g_device_connected_cb_table = {NULL, NULL};
+_device_changed_info_s g_device_info_changed_cb_table = {NULL, NULL};
-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 _session_notify_info_s g_session_notify_cb_table = {0, NULL, NULL, NULL, NULL};
-static sound_session_type_e g_cached_session = -1;
-
-#define SOUND_SESSION_TYPE_DEFAULT SOUND_SESSION_TYPE_SHARE
-
-static void __volume_changed_cb(void *user_data)
-{
- int ret = SOUND_MANAGER_ERROR_NONE;
- sound_type_e type = (sound_type_e)user_data;
-
- int new_volume;
- ret = sound_manager_get_volume(type, &new_volume);
- if (ret == SOUND_MANAGER_ERROR_NONE) {
- 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);
- } else {
- LOGE("sound_manager_get_volume() error code(0x%08x)", ret);
- }
-}
-
-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_RESUME )
- e = SOUND_INTERRUPTED_COMPLETED;
- else{
- switch(event){
- case MM_SESSION_EVENT_MEDIA :
- e = SOUND_INTERRUPTED_BY_MEDIA;
- break;
- case MM_SESSION_EVENT_RESUMABLE_MEDIA :
- e = SOUND_INTERRUPTED_BY_RESUMABLE_MEDIA;
- 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;
- case MM_SESSION_EVENT_EMERGENCY:
- e = SOUND_INTERRUPTED_BY_EMERGENCY;
- break;
- default :
- e = SOUND_INTERRUPTED_BY_MEDIA;
- 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_INVALID_PARAMETER;
- errorstr = "INVALID_PARAMETER";
- break;
- case SOUND_MANAGER_ERROR_INVALID_OPERATION:
- ret = SOUND_MANAGER_ERROR_INVALID_OPERATION;
- errorstr = "INVALID_OPERATION";
- break;
- case MM_ERROR_NONE:
- ret = SOUND_MANAGER_ERROR_NONE;
- errorstr = "ERROR_NONE";
- break;
- 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:
- case MM_ERROR_POLICY_DUPLICATED:
- case MM_ERROR_POLICY_BLOCKED:
- case MM_ERROR_POLICY_INTERNAL:
- ret = SOUND_MANAGER_ERROR_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" ;
- break;
- }
- LOGE("[%s] %s(0x%08x) : core frameworks error code(0x%08x)",func, errorstr, ret, code);
- return ret;
-}
+sound_session_type_e g_cached_session = -1;
+sound_session_voip_mode_e g_cached_voip_mode = -1;
int sound_manager_get_max_volume(sound_type_e type, int *max)
{
int volume;
if(max == NULL)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
- if(type > MAX_VOLUME_TYPE || type < 0)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+ if(type >= SOUND_TYPE_NUM || type < 0)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
int ret = mm_sound_volume_get_step(type, &volume);
if(ret == 0)
int sound_manager_set_volume(sound_type_e type, int volume)
{
- if(type > MAX_VOLUME_TYPE || type < 0)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+ if(type >= SOUND_TYPE_NUM || type < 0)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
if(volume < 0)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
int ret = mm_sound_volume_set_value(type, volume);
+ LOGI("returns : type=%d, volume=%d, ret=0x%x", type, volume, ret);
return __convert_sound_manager_error_code(__func__, ret);
}
int sound_manager_get_volume(sound_type_e type, int *volume)
{
unsigned int uvolume;
- if(type > MAX_VOLUME_TYPE || type < 0)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+ if(type >= SOUND_TYPE_NUM || type < 0)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
if(volume == NULL)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
int ret = mm_sound_volume_get_value(type, &uvolume);
if(ret == 0)
*volume = uvolume;
+ LOGI("returns : type=%d, volume=%d, ret=0x%x", type, *volume, ret);
+
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_set_current_sound_type(sound_type_e type)
+{
+ int ret = MM_ERROR_NONE;
+ if(type >= SOUND_TYPE_NUM || type < 0)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+
+ ret = mm_sound_volume_primary_type_set(type);
+
return __convert_sound_manager_error_code(__func__, ret);
}
int sound_manager_get_current_sound_type(sound_type_e *type)
{
+ int ret = MM_ERROR_NONE;
if(type == NULL)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
- int ret;
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
ret = mm_sound_volume_get_current_playing_type((volume_type_t *)type);
+ LOGI("returns : type=%d, ret=0x%x", *type, ret);
+
return __convert_sound_manager_error_code(__func__, ret);
}
-int sound_manager_set_volume_changed_cb(sound_manager_volume_changed_cb callback, void* user_data)
+int sound_manager_unset_current_sound_type(void)
{
- if(callback == NULL)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
- long 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);
- }
- return 0;
+ int ret = MM_ERROR_NONE;
+ ret = mm_sound_volume_primary_type_clear();
+
+ return __convert_sound_manager_error_code(__func__, ret);
}
-void sound_manager_unset_volume_changed_cb(void)
+int sound_manager_set_volume_changed_cb(sound_manager_volume_changed_cb callback, void* user_data)
{
- int i;
- for(i = 0 ; i <= MAX_VOLUME_TYPE ; i++)
- {
- mm_sound_volume_remove_callback(i);
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_add_volume_changed_callback((mm_sound_volume_changed_cb)callback, user_data);
+ if (ret == MM_ERROR_NONE) {
+ g_volume_changed_cb_table.user_cb = (sound_manager_volume_changed_cb)callback;
+ g_volume_changed_cb_table.user_data = user_data;
}
- g_volume_changed_cb_table.user_cb = NULL;
- g_volume_changed_cb_table.user_data = NULL;
+
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
}
-int sound_manager_get_a2dp_status(bool *connected , char** bt_name){
- int ret = mm_sound_route_get_a2dp_status(connected , bt_name);
+int sound_manager_unset_volume_changed_cb(void)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ if (g_volume_changed_cb_table.user_cb) {
+ ret = mm_sound_remove_volume_changed_callback();
+ if (ret == MM_ERROR_NONE) {
+ g_volume_changed_cb_table.user_cb = NULL;
+ g_volume_changed_cb_table.user_data = NULL;
+ }
+ } else {
+ ret = MM_ERROR_SOUND_INTERNAL;
+ }
+#endif
return __convert_sound_manager_error_code(__func__, ret);
}
-int sound_manager_set_session_type(sound_session_type_e type){
- int ret = 0;
- int session = 0;
- if(type < 0 || type > SOUND_SESSION_TYPE_EMERGENCY)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+int sound_manager_set_session_type(sound_session_type_e type)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ int cur_session = -1;
+ int new_session = MM_SESSION_TYPE_MEDIA;
+
+ LOGI(">> enter : type=%d", type);
- /* if call session is activated, can't set session */
- ret = mm_session_get_current_type(&session);
- if( ret == 0 && session >= MM_SESSION_TYPE_CALL ) {
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_OPERATION);
+ if(type < SOUND_SESSION_TYPE_MEDIA || type > SOUND_SESSION_TYPE_VOIP)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+
+ switch(type) {
+ case SOUND_SESSION_TYPE_MEDIA:
+ new_session = MM_SESSION_TYPE_MEDIA;
+ break;
+ case SOUND_SESSION_TYPE_ALARM:
+ new_session = MM_SESSION_TYPE_ALARM;
+ break;
+ case SOUND_SESSION_TYPE_NOTIFICATION:
+ new_session = MM_SESSION_TYPE_NOTIFY;
+ break;
+ case SOUND_SESSION_TYPE_EMERGENCY:
+ new_session = MM_SESSION_TYPE_EMERGENCY;
+ break;
+ case SOUND_SESSION_TYPE_VOIP:
+ new_session = MM_SESSION_TYPE_VOIP;
+ break;
}
- if(g_session_notify_cb_table.is_registered){
- ret = mm_session_finish();
- if (ret != MM_ERROR_NONE) {
- return __convert_sound_manager_error_code(__func__, ret);
+ /* valid session check */
+ ret = mm_session_get_current_type(&cur_session);
+ if(ret == 0) {
+ if (cur_session == MM_SESSION_TYPE_MEDIA_RECORD) {
+ if (type > SOUND_SESSION_TYPE_MEDIA) {
+ LOGE("<< leave : Could not set this type(%d) during camera/recorder/audio-io(in)/radio", type);
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ }
+ if (cur_session == MM_SESSION_TYPE_CALL ||
+ cur_session == MM_SESSION_TYPE_VIDEOCALL ||
+ cur_session >= MM_SESSION_TYPE_VOICE_RECOGNITION) {
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
}
- g_session_notify_cb_table.is_registered = 0;
}
- ret = mm_session_init_ex(type , __session_notify_cb, NULL);
+ if(g_session_interrupt_cb_table.is_registered) {
+ if (new_session == cur_session ||
+ ((new_session == SOUND_SESSION_TYPE_MEDIA) && (cur_session == MM_SESSION_TYPE_MEDIA_RECORD))) {
+ LOGI("<< leave : already set type=%d, ret=0x%x", type, ret);
+ return SOUND_MANAGER_ERROR_NONE;
+ } else {
+ ret = mm_session_finish();
+ if (ret != MM_ERROR_NONE) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ g_session_interrupt_cb_table.is_registered = 0;
+ g_cached_voip_mode = -1;
+ }
+ }
+ ret = mm_session_init_ex(new_session , __session_interrupt_cb, NULL);
if(ret == 0){
- g_session_notify_cb_table.is_registered = 1;
+ g_session_interrupt_cb_table.is_registered = 1;
+ }
+ if (new_session == MM_SESSION_TYPE_VOIP) {
+ /* set default sub-session for voip */
+ ret = mm_session_set_subsession (MM_SUBSESSION_TYPE_RINGTONE, MM_SUBSESSION_OPTION_NONE);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ g_cached_voip_mode = SOUND_SESSION_VOIP_MODE_RINGTONE;
}
+ LOGI("<< leave : type=%d, ret=0x%x", type, ret);
+
+#endif
return __convert_sound_manager_error_code(__func__, ret);
}
-int sound_manager_get_session_type(sound_session_type_e *type){
+int sound_manager_get_session_type(sound_session_type_e *type)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ int cur_session;
+
if( type == NULL )
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
- int ret = 0;
- int session;
- ret = mm_session_get_current_type(&session);
- if( ret !=0 )
- session = SOUND_SESSION_TYPE_DEFAULT;
- if( session > SOUND_SESSION_TYPE_EMERGENCY ){ // call session or voip session
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+ ret = mm_session_get_current_type(&cur_session);
+ if (ret != 0)
+ cur_session = SOUND_SESSION_TYPE_DEFAULT;
+ if ((cur_session > MM_SESSION_TYPE_EMERGENCY) && (cur_session != MM_SESSION_TYPE_VOIP)) {
if( g_cached_session != -1 )
- session = g_cached_session; // saved session
+ cur_session = g_cached_session;
else //will be never reach here. just prevent code
- session = SOUND_SESSION_TYPE_DEFAULT;
+ cur_session = SOUND_SESSION_TYPE_DEFAULT;
}
- *type = session;
+ switch(cur_session) {
+ case MM_SESSION_TYPE_MEDIA:
+ case MM_SESSION_TYPE_MEDIA_RECORD:
+ *type = SOUND_SESSION_TYPE_MEDIA;
+ break;
+ case MM_SESSION_TYPE_ALARM:
+ *type = SOUND_SESSION_TYPE_ALARM;
+ break;
+ case MM_SESSION_TYPE_NOTIFY:
+ *type = SOUND_SESSION_TYPE_NOTIFICATION;
+ break;
+ case MM_SESSION_TYPE_EMERGENCY:
+ *type = SOUND_SESSION_TYPE_EMERGENCY;
+ break;
+ case MM_SESSION_TYPE_VOIP:
+ *type = SOUND_SESSION_TYPE_VOIP;
+ break;
+ default:
+ *type = cur_session;
+ break;
+ }
+
+ LOGI("returns : type=%d, ret=0x%x", *type, ret);
+
+#endif
return 0;
}
+int sound_manager_set_media_session_option(sound_session_option_for_starting_e s_option, sound_session_option_for_during_play_e d_option)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ int session = 0;
+ int session_option = 0;
+ int updated = 0;
+
+ LOGI(">> enter : option for starting=%d, for during play=%d", s_option, d_option);
+
+ if(s_option < 0 || s_option > SOUND_SESSION_OPTION_PAUSE_OTHERS_WHEN_START)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+ if(d_option < 0 || d_option > SOUND_SESSION_OPTION_UNINTERRUPTIBLE_DURING_PLAY)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+
+ ret = mm_session_get_current_information(&session, &session_option);
+ if ( ret != 0 || !g_session_interrupt_cb_table.is_registered) {
+ LOGW("need to set session type first");
+ return __convert_sound_manager_error_code(__func__, ret);
+ } else if ( ret == 0 && session > MM_SESSION_TYPE_MEDIA ) {
+ if (session == MM_SESSION_TYPE_MEDIA_RECORD) {
+ if (!g_session_interrupt_cb_table.is_registered) {
+ LOGE("Already set by camera/recorder/audio-io(in)/radio API, but need to set session to Media first");
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ } else {
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ }
-int sound_manager_set_session_notify_cb(sound_session_notify_cb callback , void *user_data){
- int ret =0 ;
- if(callback == NULL)
- return __convert_sound_manager_error_code(__func__, SOUND_MANAGER_ERROR_INVALID_PARAMETER);
+ switch (s_option) {
+ case SOUND_SESSION_OPTION_MIX_WITH_OTHERS_WHEN_START:
+ if (session_option & MM_SESSION_OPTION_PAUSE_OTHERS) {
+ ret = mm_session_update_option(MM_SESSION_UPDATE_TYPE_REMOVE, MM_SESSION_OPTION_PAUSE_OTHERS);
+ if(ret){
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ updated = 1;
+ }
+ break;
+ case SOUND_SESSION_OPTION_PAUSE_OTHERS_WHEN_START:
+ if (!(session_option & MM_SESSION_OPTION_PAUSE_OTHERS)) {
+ ret = mm_session_update_option(MM_SESSION_UPDATE_TYPE_ADD, MM_SESSION_OPTION_PAUSE_OTHERS);
+ if(ret){
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ updated = 1;
+ }
+ break;
+ }
+ switch (d_option) {
+ case SOUND_SESSION_OPTION_INTERRUPTIBLE_DURING_PLAY:
+ if (session_option & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
+ ret = mm_session_update_option(MM_SESSION_UPDATE_TYPE_REMOVE, MM_SESSION_OPTION_UNINTERRUPTIBLE);
+ if(ret){
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ updated = 1;
+ }
+ break;
+ case SOUND_SESSION_OPTION_UNINTERRUPTIBLE_DURING_PLAY:
+ if (!(session_option & MM_SESSION_OPTION_UNINTERRUPTIBLE)) {
+ ret = mm_session_update_option(MM_SESSION_UPDATE_TYPE_ADD, MM_SESSION_OPTION_UNINTERRUPTIBLE);
+ if(ret){
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ updated = 1;
+ }
+ break;
+ }
- if(g_session_notify_cb_table.is_registered ==0){
- ret = mm_session_init_ex(SOUND_SESSION_TYPE_DEFAULT /*default*/ , __session_notify_cb, NULL);
- if(ret != 0)
- return __convert_sound_manager_error_code(__func__, ret);
- g_session_notify_cb_table.is_registered = 1;
+ if (updated) {
+ LOGI("<< leave : updated");
+ } else {
+ LOGI("<< leave : already set same option(%x), skip it", session_option);
}
- g_session_notify_cb_table.user_cb = callback;
- g_session_notify_cb_table.user_data = user_data;
- return SOUND_MANAGER_ERROR_NONE;
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
}
-void sound_manager_unset_session_notify_cb(void){
- g_session_notify_cb_table.user_cb = NULL;
- g_session_notify_cb_table.user_data = NULL;
-}
+int sound_manager_get_media_session_option(sound_session_option_for_starting_e *s_option, sound_session_option_for_during_play_e *d_option)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ int session = 0;
+ int session_options = 0;
-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);
+ LOGI(">> enter");
- if(g_session_notify_cb_table.is_registered ==0){
- ret = mm_session_init_ex(SOUND_SESSION_TYPE_DEFAULT /*default*/ , __session_notify_cb, NULL);
- if(ret != 0)
- return __convert_sound_manager_error_code(__func__, ret);
- g_session_notify_cb_table.is_registered = 1;
+ if( s_option == NULL || d_option == NULL )
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+
+ ret = mm_session_get_current_information(&session, &session_options);
+ if( ret != 0 ) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ } else if (session > SOUND_SESSION_TYPE_MEDIA ) {
+ if (session == MM_SESSION_TYPE_MEDIA_RECORD) {
+ if (!g_session_interrupt_cb_table.is_registered) {
+ LOGE("Already set by camera/recorder/audio-io(in)/radio API, but need to set session to Media first");
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ } else {
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ }
+ /* get option */
+ if (session_options & MM_SESSION_OPTION_PAUSE_OTHERS) {
+ *s_option = SOUND_SESSION_OPTION_PAUSE_OTHERS_WHEN_START;
+ } else {
+ *s_option = SOUND_SESSION_OPTION_MIX_WITH_OTHERS_WHEN_START;
+ }
+ if (session_options & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
+ *d_option = SOUND_SESSION_OPTION_UNINTERRUPTIBLE_DURING_PLAY;
+ } else {
+ *d_option = SOUND_SESSION_OPTION_INTERRUPTIBLE_DURING_PLAY;
}
- g_session_notify_cb_table.interrupted_cb= callback;
- g_session_notify_cb_table.interrupted_user_data = user_data;
+ LOGI("<< leave : option for starting=%d, for during play=%d", *s_option, *d_option);
+
+#endif
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_media_session_resumption_option(sound_session_option_for_resumption_e option)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ int session = 0;
+ int session_option = 0;
+ int updated = 0;
+
+ LOGI(">> enter : option for resumption=%d (0:by system, 1:by system or media paused)", option);
+
+ if(option < SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM || option > SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM_OR_MEDIA_PAUSED)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+
+ ret = mm_session_get_current_information(&session, &session_option);
+ if ( ret != 0 || !g_session_interrupt_cb_table.is_registered) {
+ LOGW("need to set session type first");
+ return __convert_sound_manager_error_code(__func__, ret);
+ } else if ( ret == 0 && session > MM_SESSION_TYPE_MEDIA ) {
+ if (session == MM_SESSION_TYPE_MEDIA_RECORD) {
+ if (!g_session_interrupt_cb_table.is_registered) {
+ LOGE("Already set by camera/recorder/audio-io(in)/radio API, but need to set session to Media first");
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ } else {
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ }
+
+ switch (option) {
+ case SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM:
+ if (session_option & MM_SESSION_OPTION_RESUME_BY_SYSTEM_OR_MEDIA_PAUSED) {
+ ret = mm_session_update_option(MM_SESSION_UPDATE_TYPE_REMOVE, MM_SESSION_OPTION_RESUME_BY_SYSTEM_OR_MEDIA_PAUSED);
+ if(ret){
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ updated = 1;
+ }
+ break;
+ case SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM_OR_MEDIA_PAUSED:
+ if (!(session_option & MM_SESSION_OPTION_RESUME_BY_SYSTEM_OR_MEDIA_PAUSED)) {
+ ret = mm_session_update_option(MM_SESSION_UPDATE_TYPE_ADD, MM_SESSION_OPTION_RESUME_BY_SYSTEM_OR_MEDIA_PAUSED);
+ if(ret){
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ updated = 1;
+ }
+ break;
+ }
+
+ if (updated) {
+ LOGI("<< leave : updated");
+ } else {
+ LOGI("<< leave : already set same option(%x), skip it", session_option);
+ }
+
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
}
+int sound_manager_get_media_session_resumption_option(sound_session_option_for_resumption_e *option)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ int session = 0;
+ int session_options = 0;
+
+ LOGI(">> enter");
+
+ if( option == NULL )
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+ ret = mm_session_get_current_information(&session, &session_options);
+ if( ret != 0 ) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ } else if (session > SOUND_SESSION_TYPE_MEDIA ) {
+ if (session == MM_SESSION_TYPE_MEDIA_RECORD) {
+ if (!g_session_interrupt_cb_table.is_registered) {
+ LOGE("Already set by camera/recorder/audio-io(in)/radio API, but need to set session to Media first");
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ } else {
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+ }
+ /* get option */
+ if (session_options & MM_SESSION_OPTION_RESUME_BY_SYSTEM_OR_MEDIA_PAUSED) {
+ *option = SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM_OR_MEDIA_PAUSED;
+ } else {
+ *option = SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM;
+ }
-int sound_manager_set_volume_key_type(volume_key_type_e type){
- 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)
- ret = mm_sound_volume_primary_type_clear();
- else
- ret = mm_sound_volume_primary_type_set(type);
+ LOGI("<< leave : option for resumption=%d (0:by system, 1:by system or media paused)", *option);
+
+#endif
+ return SOUND_MANAGER_ERROR_NONE;
+}
+int sound_manager_set_voip_session_mode(sound_session_voip_mode_e mode)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ int session = 0;
+ int session_options = 0;
+
+ LOGI(">> enter : mode=%d", mode);
+
+ ret = mm_session_get_current_information(&session, &session_options);
+ if( ret != MM_ERROR_NONE ) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ } else if (session != MM_SESSION_TYPE_VOIP ) {
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+
+ if(mode < SOUND_SESSION_VOIP_MODE_RINGTONE || mode > SOUND_SESSION_VOIP_MODE_VOICE_WITH_BLUETOOTH) {
+ ret = MM_ERROR_INVALID_ARGUMENT;
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+
+ if (mode == SOUND_SESSION_VOIP_MODE_RINGTONE) {
+ /* sub-session */
+ if (g_cached_voip_mode != mode) {
+ ret = mm_session_set_subsession (MM_SUBSESSION_TYPE_RINGTONE, MM_SUBSESSION_OPTION_NONE);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ }
+ g_cached_voip_mode = mode;
+ } else {
+ mm_sound_route route;
+ bool need_to_check_device = false;
+ bool do_subsession = true;
+ switch (mode) {
+ case SOUND_SESSION_VOIP_MODE_RINGTONE:
+ do_subsession = false;
+ break;
+ case SOUND_SESSION_VOIP_MODE_VOICE_WITH_BUILTIN_RECEIVER:
+ route = MM_SOUND_ROUTE_IN_MIC_OUT_RECEIVER;
+ break;
+ case SOUND_SESSION_VOIP_MODE_VOICE_WITH_BUILTIN_SPEAKER:
+ route = MM_SOUND_ROUTE_IN_MIC_OUT_SPEAKER;
+ break;
+ case SOUND_SESSION_VOIP_MODE_VOICE_WITH_AUDIO_JACK:
+ route = MM_SOUND_ROUTE_IN_MIC_OUT_HEADPHONE;
+ need_to_check_device = true;
+ break;
+ case SOUND_SESSION_VOIP_MODE_VOICE_WITH_BLUETOOTH:
+ route = MM_SOUND_ROUTE_INOUT_BLUETOOTH;
+ need_to_check_device = true;
+ break;
+ }
+
+ if (need_to_check_device) {
+ int w_ret = MM_ERROR_NONE;
+ MMSoundDeviceList_t device_list;
+ MMSoundDevice_t device;
+ do_subsession = false;
+
+ ret = mm_sound_get_current_device_list(MM_SOUND_DEVICE_STATE_DEACTIVATED_FLAG, &device_list);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ } else {
+ while ((w_ret = mm_sound_get_next_device(device_list, &device)) == MM_ERROR_NONE) {
+ mm_sound_device_type_e type;
+ ret = mm_sound_get_device_type(device, &type);
+ if (ret != MM_ERROR_NONE)
+ return __convert_sound_manager_error_code(__func__, ret);
+
+ switch (mode) {
+ case SOUND_SESSION_VOIP_MODE_VOICE_WITH_AUDIO_JACK:
+ if (type == MM_SOUND_DEVICE_TYPE_AUDIOJACK)
+ do_subsession = true;
+ break;
+ case SOUND_SESSION_VOIP_MODE_VOICE_WITH_BLUETOOTH:
+ if (type == MM_SOUND_DEVICE_TYPE_BLUETOOTH) {
+ mm_sound_device_io_direction_e io_direction;
+ ret = mm_sound_get_device_io_direction(device, &io_direction);
+ if (ret != MM_ERROR_NONE)
+ return __convert_sound_manager_error_code(__func__, ret);
+ if (io_direction == MM_SOUND_DEVICE_IO_DIRECTION_BOTH)
+ do_subsession = true;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ /* sub-session */
+ if (do_subsession && (g_cached_voip_mode != mode)) {
+ ret = mm_session_set_subsession (MM_SUBSESSION_TYPE_VOICE, MM_SUBSESSION_OPTION_NONE);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ /* route */
+ ret = mm_sound_set_active_route(route);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ g_cached_voip_mode = mode;
+ } else {
+ if (!do_subsession)
+ ret = MM_ERROR_SOUND_INTERNAL;
+ }
+ }
+
+ LOGI("<< leave : session=%p, mode=%d, ret=0x%x", session, mode, ret);
+
+#endif
return __convert_sound_manager_error_code(__func__, ret);
}
-int sound_manager_foreach_available_route (sound_available_route_cb callback, void *user_data)
+int sound_manager_get_voip_session_mode(sound_session_voip_mode_e *mode)
{
- int ret;
- ret = mm_sound_foreach_available_route_cb((mm_sound_available_route_cb)callback, user_data);
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ int session = 0;
+ int session_options = 0;
+ int subsession = 0;
+
+ if(mode == NULL) {
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+ }
+ ret = mm_session_get_current_information(&session, &session_options);
+ if( ret != MM_ERROR_NONE ) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ } else if (session != MM_SESSION_TYPE_VOIP ) {
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_POLICY_INTERNAL);
+ }
+
+ ret = mm_session_get_subsession ((mm_subsession_t *)&subsession);
+ if(ret != MM_ERROR_NONE) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ }
+ switch (subsession) {
+ case MM_SUBSESSION_TYPE_VOICE:
+ {
+ int w_ret = MM_ERROR_NONE;
+ bool need_to_out = false;
+ MMSoundDeviceList_t device_list;
+ MMSoundDevice_t device;
+ ret = mm_sound_get_current_device_list(MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG, &device_list);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_sound_manager_error_code(__func__, ret);
+ } else {
+ while ((w_ret = mm_sound_get_next_device(device_list, &device)) == MM_ERROR_NONE) {
+ mm_sound_device_type_e type;
+ ret = mm_sound_get_device_type(device, &type);
+ if (ret != MM_ERROR_NONE)
+ return __convert_sound_manager_error_code(__func__, ret);
+ switch (type) {
+ case MM_SOUND_DEVICE_TYPE_BUILTIN_SPEAKER:
+ *mode = SOUND_SESSION_VOIP_MODE_VOICE_WITH_BUILTIN_SPEAKER;
+ need_to_out = true;
+ break;
+ case MM_SOUND_DEVICE_TYPE_BUILTIN_RECEIVER:
+ *mode = SOUND_SESSION_VOIP_MODE_VOICE_WITH_BUILTIN_RECEIVER;
+ need_to_out = true;
+ break;
+ case MM_SOUND_DEVICE_TYPE_AUDIOJACK:
+ *mode = SOUND_SESSION_VOIP_MODE_VOICE_WITH_AUDIO_JACK;
+ need_to_out = true;
+ break;
+ case MM_SOUND_DEVICE_TYPE_BLUETOOTH:
+ *mode = SOUND_SESSION_VOIP_MODE_VOICE_WITH_BLUETOOTH;
+ need_to_out = true;
+ break;
+ default:
+ break;
+ }
+ if (need_to_out)
+ break;
+ }
+ }
+ }
+ break;
+ case MM_SUBSESSION_TYPE_RINGTONE:
+ *mode = SOUND_SESSION_VOIP_MODE_RINGTONE;
+ break;
+ default:
+ break;
+ }
+
+ LOGI("returns : session=%p, mode=%d, ret=0x%x", session, *mode, ret);
+
+#endif
return __convert_sound_manager_error_code(__func__, ret);
}
-int sound_manager_set_active_route (sound_route_e route)
+int sound_manager_set_session_interrupted_cb(sound_session_interrupted_cb callback, void *user_data)
{
- int ret;
- ret = mm_sound_set_active_route(route);
+ int ret = MM_ERROR_NONE;
+ if(callback == NULL)
+ return __convert_sound_manager_error_code(__func__, MM_ERROR_INVALID_ARGUMENT);
+
+ if(g_session_interrupt_cb_table.is_registered ==0){
+ ret = mm_session_init_ex(SOUND_SESSION_TYPE_DEFAULT /*default*/ , __session_interrupt_cb, NULL);
+ if(ret != 0)
+ return __convert_sound_manager_error_code(__func__, ret);
+ g_session_interrupt_cb_table.is_registered = 1;
+ }
+
+ g_session_interrupt_cb_table.user_cb = (sound_session_interrupted_cb)callback;
+ g_session_interrupt_cb_table.user_data = user_data;
+ return SOUND_MANAGER_ERROR_NONE;
+}
+int sound_manager_unset_session_interrupted_cb(void)
+{
+ int ret = MM_ERROR_NONE;
+ if (g_session_interrupt_cb_table.user_cb) {
+ g_session_interrupt_cb_table.user_cb = NULL;
+ g_session_interrupt_cb_table.user_data = NULL;
+ } else {
+ ret = MM_ERROR_SOUND_INTERNAL;
+ }
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 sound_manager_get_current_device_list(sound_device_mask_e device_mask, sound_device_list_h *device_list)
{
- int ret;
- ret = mm_sound_get_active_device((mm_sound_device_in *)in, (mm_sound_device_out *)out);
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_get_current_device_list((mm_sound_device_flags_e)device_mask, device_list);
+#endif
return __convert_sound_manager_error_code(__func__, ret);
}
-bool sound_manager_is_route_available (sound_route_e route)
+int sound_manager_get_next_device (sound_device_list_h device_list, sound_device_h *device)
{
- bool is_available;
- mm_sound_is_route_available(route, &is_available);
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_get_next_device(device_list, device);
- return is_available;
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
}
-int sound_manager_set_available_route_changed_cb (sound_available_route_changed_cb callback, void *user_data)
+int sound_manager_get_prev_device (sound_device_list_h device_list, sound_device_h *device)
{
- int ret;
- ret = mm_sound_add_available_route_changed_callback((mm_sound_available_route_changed_cb)callback, user_data);
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_get_prev_device(device_list, device);
+#endif
return __convert_sound_manager_error_code(__func__, ret);
}
-void sound_manager_unset_available_route_changed_cb (void)
+int sound_manager_get_device_type (sound_device_h device, sound_device_type_e *type)
{
- mm_sound_remove_available_route_changed_callback();
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_get_device_type(device, (mm_sound_device_type_e*)type);
+
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
}
-int sound_manager_set_active_device_changed_cb (sound_active_device_changed_cb callback, void *user_data)
+int sound_manager_get_device_io_direction (sound_device_h device, sound_device_io_direction_e *io_direction)
{
- int ret;
- ret = mm_sound_add_active_device_changed_callback((mm_sound_active_device_changed_cb)callback, user_data);
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_get_device_io_direction(device, (mm_sound_device_io_direction_e*)io_direction);
+#endif
return __convert_sound_manager_error_code(__func__, ret);
}
-void sound_manager_unset_active_device_changed_cb (void)
+int sound_manager_get_device_id (sound_device_h device, int *id)
{
- mm_sound_remove_active_device_changed_callback();
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_get_device_id(device, id);
+
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
}
-struct sound_call_session_s
+int sound_manager_get_device_name (sound_device_h device, char **name)
{
- int previous_session;
-};
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_get_device_name(device, name);
-int sound_manager_call_session_create(sound_call_session_type_e type, sound_call_session_h *session)
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
+}
+
+int sound_manager_get_device_state (sound_device_h device, sound_device_state_e *state)
{
- int ret = SOUND_MANAGER_ERROR_NONE;
- sound_call_session_h handle = NULL;
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_get_device_state(device, (mm_sound_device_state_e*)state);
- /* Check input parameters */
- if(type < SOUND_SESSION_TYPE_CALL || type > SOUND_SESSION_TYPE_VOIP || session == NULL) {
- ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
- goto ERROR;
- }
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
+}
- /* Allocate handle */
- handle = malloc(sizeof(struct sound_call_session_s));
- if(!handle) {
- ret = SOUND_MANAGER_ERROR_OUT_OF_MEMORY;
- goto ERROR;
+int sound_manager_set_device_connected_cb (sound_device_mask_e device_mask, sound_device_connected_cb callback, void *user_data)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_add_device_connected_callback((mm_sound_device_flags_e)device_mask, (mm_sound_device_connected_cb)callback, user_data);
+ if (ret == MM_ERROR_NONE) {
+ g_device_connected_cb_table.user_cb = (sound_device_connected_cb)callback;
+ g_device_connected_cb_table.user_data = user_data;
}
- memset(handle, 0, sizeof(struct sound_call_session_s));
- /* Finish previous session if exists */
- if(g_session_notify_cb_table.is_registered){
- sound_manager_get_session_type((sound_session_type_e*)&handle->previous_session);
- g_cached_session = handle->previous_session;
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
+}
- ret = mm_session_finish();
- if (ret != MM_ERROR_NONE) {
- goto ERROR;
+int sound_manager_unset_device_connected_cb (void)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ if (g_device_connected_cb_table.user_cb) {
+ ret = mm_sound_remove_device_connected_callback();
+ if (ret == MM_ERROR_NONE) {
+ g_device_connected_cb_table.user_cb = NULL;
+ g_device_connected_cb_table.user_data = NULL;
}
- g_session_notify_cb_table.is_registered = 0;
-
- }else{
- g_cached_session = SOUND_SESSION_TYPE_DEFAULT;
- handle->previous_session = SOUND_SESSION_TYPE_DEFAULT;
+ } else {
+ ret = MM_ERROR_SOUND_INTERNAL;
}
- /* Initialize session */
- switch(type) {
- case SOUND_SESSION_TYPE_CALL:
- ret = mm_session_init_ex(MM_SESSION_TYPE_CALL, __session_notify_cb, NULL);
- break;
- case SOUND_SESSION_TYPE_VOIP:
- ret = mm_session_init_ex(MM_SESSION_TYPE_VIDEOCALL,__session_notify_cb, NULL);
- break;
- }
- if(ret != MM_ERROR_NONE)
- goto ERROR;
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
+}
- g_session_notify_cb_table.is_registered = 1;
- *session = handle;
+int sound_manager_set_device_information_changed_cb (sound_device_mask_e device_mask, sound_device_information_changed_cb callback, void *user_data)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ ret = mm_sound_add_device_information_changed_callback((mm_sound_device_flags_e)device_mask, (mm_sound_device_info_changed_cb)callback, user_data);
+ if (ret == MM_ERROR_NONE) {
+ g_device_info_changed_cb_table.user_cb = (sound_device_information_changed_cb)callback;
+ g_device_info_changed_cb_table.user_data = user_data;
+ }
- return SOUND_MANAGER_ERROR_NONE;
+#endif
+ return __convert_sound_manager_error_code(__func__, ret);
+}
-ERROR:
- if(handle)
- free(handle);
+int sound_manager_unset_device_information_changed_cb (void)
+{
+ int ret = MM_ERROR_NONE;
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ if (g_device_info_changed_cb_table.user_cb) {
+ ret = mm_sound_remove_device_information_changed_callback();
+ if (ret == MM_ERROR_NONE) {
+ g_device_info_changed_cb_table.user_cb = NULL;
+ g_device_info_changed_cb_table.user_data = NULL;
+ }
+ } else {
+ ret = MM_ERROR_SOUND_INTERNAL;
+ }
+#endif
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)
+/* below APIs are already deprecated Tizen 2.3, leave it temporarily */
+int sound_manager_get_a2dp_status(bool *connected , char** bt_name)
{
- int ret = SOUND_MANAGER_ERROR_NONE;
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
- if(mode < SOUND_CALL_SESSION_MODE_VOICE || mode > SOUND_CALL_SESSION_MODE_MEDIA || session == NULL) {
- ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
- goto ERROR;
- }
+int sound_manager_set_session_notify_cb(sound_session_notify_cb callback , void *user_data)
+{
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
- ret = mm_session_set_subsession ((mm_subsession_t)mode);
+void sound_manager_unset_session_notify_cb(void)
+{
+ return;
+}
- if(ret != MM_ERROR_NONE)
- goto ERROR;
+int sound_manager_set_interrupted_cb(sound_interrupted_cb callback, void *user_data){
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
- return SOUND_MANAGER_ERROR_NONE;
+void sound_manager_unset_interrupted_cb(void){
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
-ERROR:
- return __convert_sound_manager_error_code(__func__, ret);
+int sound_manager_set_volume_key_type(volume_key_type_e type){
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
}
-int sound_manager_call_session_get_mode(sound_call_session_h session, sound_call_session_mode_e *mode)
+int sound_manager_foreach_available_route (sound_available_route_cb callback, void *user_data)
{
- int ret = SOUND_MANAGER_ERROR_NONE;
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
- if(mode == NULL || session == NULL) {
- ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
- goto ERROR;
- }
+int sound_manager_set_active_route (sound_route_e route)
+{
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
- ret = mm_session_get_subsession ((mm_subsession_t *)mode);
+int sound_manager_get_active_device (sound_device_in_e *in, sound_device_out_e *out)
+{
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
- if(ret != MM_ERROR_NONE)
- goto ERROR;
+bool sound_manager_is_route_available (sound_route_e route)
+{
+ return false;
+}
- return SOUND_MANAGER_ERROR_NONE;
+int sound_manager_set_available_route_changed_cb (sound_available_route_changed_cb callback, void *user_data)
+{
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
-ERROR:
- return __convert_sound_manager_error_code(__func__, ret);
+void sound_manager_unset_available_route_changed_cb (void)
+{
+ return;
}
-int sound_manager_call_session_destroy(sound_call_session_h session)
+int sound_manager_set_active_device_changed_cb (sound_active_device_changed_cb callback, void *user_data)
{
- int ret = SOUND_MANAGER_ERROR_NONE;
+ return SOUND_MANAGER_ERROR_NOT_SUPPORTED;
+}
- if(session == NULL) {
- ret = SOUND_MANAGER_ERROR_INVALID_PARAMETER;
- goto ERROR;
- }
+void sound_manager_unset_active_device_changed_cb (void)
+{
+ return;
+}
- if(g_session_notify_cb_table.is_registered){
- ret = mm_session_finish();
- if(ret != MM_ERROR_NONE)
- goto ERROR;
- g_session_notify_cb_table.is_registered = 0;
- }
+__attribute__ ((destructor))
+void __sound_manager_finalize(void)
+{
+ int ret = MM_ERROR_NONE;
- /* Restore previous session */
- ret = mm_session_init_ex(session->previous_session , __session_notify_cb, NULL);
- if(ret == 0){
- g_session_notify_cb_table.is_registered = 1;
+ if(g_session_interrupt_cb_table.is_registered){
+ LOGI("<ENTER>");
+ ret = mm_session_finish();
+ if (ret != MM_ERROR_NONE) {
+ LOGE("[%s] failed to mm_session_finish(), ret(0x%x)", __func__, ret);
+ }
+ g_session_interrupt_cb_table.is_registered = 0;
+ LOGI("<LEAVE>");
}
+}
- if(session)
- free(session);
-
- return SOUND_MANAGER_ERROR_NONE;
+__attribute__ ((constructor))
+void __sound_manager_initialize(void)
+{
-ERROR:
- return __convert_sound_manager_error_code(__func__, ret);
}
-
--- /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 <sound_manager.h>
+#include <sound_manager_private.h>
+
+#include <mm_sound.h>
+#include <dlog.h>
+
+extern _session_interrupt_info_s g_session_interrupt_cb_table;
+
+int __convert_sound_manager_error_code(const char *func, int code) {
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ char *errorstr = NULL;
+
+ switch(code)
+ {
+ case MM_ERROR_FILE_WRITE:
+ case MM_ERROR_INVALID_HANDLE:
+ ret = SOUND_MANAGER_ERROR_INVALID_OPERATION;
+ errorstr = "INVALID_OPERATION";
+ break;
+ case MM_ERROR_NONE:
+ ret = SOUND_MANAGER_ERROR_NONE;
+ errorstr = "ERROR_NONE";
+ break;
+ 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_PERMISSION_DENIED:
+ ret = SOUND_MANAGER_ERROR_PERMISSION_DENIED;
+ errorstr = "PERMISSION_DENIED";
+ break;
+ case MM_ERROR_SOUND_NO_DATA:
+ ret = SOUND_MANAGER_ERROR_NO_DATA;
+ errorstr = "NO_DATA";
+ break;
+ case MM_ERROR_SOUND_INTERNAL:
+ case MM_ERROR_SOUND_VOLUME_CAPTURE_ONLY:
+ ret = SOUND_MANAGER_ERROR_INTERNAL;
+ errorstr = "INTERNAL";
+ break;
+ case MM_ERROR_POLICY_DUPLICATED:
+ case MM_ERROR_POLICY_INTERNAL:
+ case MM_ERROR_POLICY_BLOCKED:
+ ret = SOUND_MANAGER_ERROR_POLICY;
+ errorstr = "POLICY";
+ break;
+ case MM_ERROR_SOUND_VOLUME_NO_INSTANCE:
+ ret = SOUND_MANAGER_ERROR_NO_PLAYING_SOUND;
+ errorstr = "NO_PLAYING_SOUND";
+ break;
+ }
+ LOGE("[%s] %s(0x%08x) : core frameworks error code(0x%08x)",func, errorstr, ret, code);
+ return ret;
+}
+
+void __session_interrupt_cb(session_msg_t msg, session_event_t event, void *user_data){
+ if( g_session_interrupt_cb_table.user_cb ){
+ sound_session_interrupted_code_e e = SOUND_SESSION_INTERRUPTED_COMPLETED;
+ if( msg == MM_SESSION_MSG_RESUME )
+ e = SOUND_SESSION_INTERRUPTED_COMPLETED;
+ else{
+#ifndef TEMP_COMMENT_UNTIL_MM_SOUND_READY
+ switch(event){
+ case MM_SESSION_EVENT_MEDIA :
+ e = SOUND_SESSION_INTERRUPTED_BY_MEDIA;
+ break;
+ case MM_SESSION_EVENT_CALL :
+ e = SOUND_SESSION_INTERRUPTED_BY_CALL;
+ break;
+ case MM_SESSION_EVENT_ALARM :
+ e = SOUND_SESSION_INTERRUPTED_BY_ALARM;
+ break;
+ case MM_SESSION_EVENT_EARJACK_UNPLUG:
+ e = SOUND_SESSION_INTERRUPTED_BY_EARJACK_UNPLUG;
+ break;
+ case MM_SESSION_EVENT_RESOURCE_CONFLICT:
+ e = SOUND_SESSION_INTERRUPTED_BY_RESOURCE_CONFLICT;
+ break;
+ case MM_SESSION_EVENT_EMERGENCY:
+ e = SOUND_SESSION_INTERRUPTED_BY_EMERGENCY;
+ break;
+ case MM_SESSION_EVENT_NOTIFICATION :
+ e = SOUND_SESSION_INTERRUPTED_BY_NOTIFICATION;
+ break;
+ default :
+ e = SOUND_SESSION_INTERRUPTED_BY_MEDIA;
+ break;
+ }
+#endif
+ }
+ g_session_interrupt_cb_table.user_cb(e, g_session_interrupt_cb_table.user_data);
+ }
+}
SET(fw_test "${fw_name}-test")
INCLUDE(FindPkgConfig)
-pkg_check_modules(${fw_test} REQUIRED mm-sound glib-2.0 gthread-2.0 capi-media-player)
+pkg_check_modules(${fw_test} REQUIRED mm-sound glib-2.0 gthread-2.0)
FOREACH(flag ${${fw_test}_CFLAGS})
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
MESSAGE(${flag})
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall")
-#ADD_EXECUTABLE("system-sensor" system-sensor.c)
-#TARGET_LINK_LIBRARIES("system-sensor" ${fw_name} ${${fw_test}_LDFLAGS})
-
aux_source_directory(. sources)
FOREACH(src ${sources})
GET_FILENAME_COMPONENT(src_name ${src} NAME_WE)
+++ /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 <stdio.h>
-#include <sound_manager.h>
-#include <glib.h>
-#include <mm_sound.h>
-#include <unistd.h>
-#include <string.h>
-#include <player.h>
-#include <stdlib.h>
-
-static GMainLoop *g_mainloop = NULL;
-static GThread *event_thread;
-#define MAX_VOLUME_TYPE 5
-
-gpointer GmainThread(gpointer data){
- g_mainloop = g_main_loop_new (NULL, 0);
- g_main_loop_run (g_mainloop);
-
- return NULL;
-}
-
-void _sound_manager_volume_changed_cb(sound_type_e type, unsigned int volume, void* user_data)
-{
- printf("changed!! type=%d, volume = %d\n", type, volume);
-}
-
-int set_volume_test()
-{
- printf("set volume test\n");
- int i;
- sound_manager_set_volume_changed_cb(_sound_manager_volume_changed_cb ,NULL);
- for( i = SOUND_TYPE_SYSTEM ; i <=MAX_VOLUME_TYPE; i++){
- int max_value;
- int j;
- sound_manager_get_max_volume(i, &max_value);
- printf(" sound type = %d , max volume = %d\n", i, max_value);
- for( j = 0; j <= max_value+1 ; j++){
- int ret;
- int getvalue;
- ret = sound_manager_set_volume(i, j);
- if( j <= max_value && ret == 0 ){
- sound_manager_get_volume(i, &getvalue);
- if( j == getvalue )
- printf("PASS\n");
- else
- printf("FAIL!set=%d, get=%d\n", j, getvalue);
- } else if( j > max_value && ret == 0 )
- printf("FAIL! max_value over!!\n");
-
- }
- }
- //sound_manager_unset_volume_changed_cb();
- printf("end set volume test!!!\n");
- sleep(10);
- return 0;
-}
-
-void _sound_manager_route_policy_changed_cb(sound_route_policy_e route , void* user_data)
-{
- printf("new route policy %d\n", route);
-}
-
-int set_policy_test()
-{
- printf("-----------set policy test--------------\n");
- int ret;
- //int i;
- //sound_route_policy_e value;
- sound_manager_set_route_policy_changed_cb(_sound_manager_route_policy_changed_cb,NULL);
- /*
- for( i = SOUND_ROUTE_DEFAULT ; i <= SOUND_ROUTE_HANDSET_ONLY ; i++){
- ret = sound_manager_set_route_policy(i);
- ret = sound_manager_get_route_policy(&value);
- if( i == value )
- printf("PASS\n");
- else
- printf("FAIL\n");
- }
- */
- ret = sound_manager_set_route_policy(SOUND_ROUTE_DEFAULT);
- ret = sound_manager_set_route_policy(SOUND_ROUTE_DEFAULT);
- ret = sound_manager_set_route_policy(SOUND_ROUTE_DEFAULT);
- ret = sound_manager_set_route_policy(SOUND_ROUTE_DEFAULT);
-
-
- return 0;
-}
-
-
-static void mm_volume_changed_cb(void *user_data)
-{
- int v = (int)user_data;
- unsigned int value = 0;
- int ret = mm_sound_volume_get_value(v, &value);
- printf("mm_volume_changed_cb type = %d ,volume = %d , ret = %x\n", v, value, ret );
-}
-
-
-int mm_bug_test()
-{
- int ret = 0;
- mm_sound_volume_add_callback(0 , mm_volume_changed_cb , (void*)0);
- mm_sound_volume_add_callback(1 , mm_volume_changed_cb ,(void*) 1);
- mm_sound_volume_add_callback(2 , mm_volume_changed_cb , (void*)2);
- mm_sound_volume_add_callback(5 , mm_volume_changed_cb , (void*)5);
-
- int i;
-
- for( i = 0 ; i < 10 ; i++)
- {
- ret = mm_sound_volume_set_value(0, i);
- printf("type = 0 , volume = %d set , ret = %x\n", i, ret);
- ret = mm_sound_volume_set_value(1, i);
- printf("type = 1 , volume = %d set , ret = %x\n", i, ret);
- ret = mm_sound_volume_set_value(2, i);
- printf("type = 2 , volume = %d set , ret = %x\n", i, ret);
- ret = mm_sound_volume_set_value(5, i);
- printf("type = 5 , volume = %d set , ret = %x\n", i, ret);
- sleep(1);
- }
-
- //mm_sound_volume_remove_callback(0);
- //mm_sound_volume_remove_callback(1);
- //mm_sound_volume_remove_callback(2);
- //mm_sound_volume_remove_callback(5);
-
-
- ret = mm_sound_volume_set_value(5, 4);
-
- mm_sound_route_set_system_policy(SOUND_ROUTE_DEFAULT);
- mm_sound_route_set_system_policy(SOUND_ROUTE_DEFAULT);
- mm_sound_route_set_system_policy(SOUND_ROUTE_DEFAULT);
- return 0;
-}
-
-void mm_test(){
-
- char path[255];
- int id;
- int i;
- getcwd(path, 255);
- strcat(path, "/test2.wav");
- for( i =0 ; i < 10 ; i++){
- mm_sound_play_sound(path, SOUND_TYPE_MEDIA, NULL ,NULL, &id);
- mm_sound_stop_sound(id);
- }
-}
-
-void session_notify_cb(sound_session_notify_e notify, void *user_data)
-{
- printf("notify %d\n", notify);
-
-
-}
-
-
-void session_test(){
- printf("session_test\n");
- int ret = 0;
- player_h player;
-
- ret = sound_manager_set_session_type(SOUND_SESSION_TYPE_EXCLUSIVE);
- sound_manager_set_session_notify_cb(session_notify_cb,NULL);
-
-
-
- ret = player_create(&player);
- printf("player_create ret =%x\n", ret);
- ret = player_set_uri(player, "title_theme.mp3");
- printf("player_set_uri ret =%x\n", ret);
- ret =player_prepare(player);
- printf("player_prepare ret =%x\n", ret);
- ret = player_start(player);
- printf("player_start ret =%x\n", ret);
-
- while(1){
- player_state_e state;
- player_get_state(player, &state);
- printf("state %d\n", state);
- //if( state == 4)
- //player_start(player);
- sleep(1);
- //wav_player_start("test.wav", SOUND_TYPE_MEDIA,NULL, NULL,NULL);
- }
-
-
-}
-
-
-void a2dp_test(){
- bool isconnected;
- char * name;
- sound_manager_get_a2dp_status(&isconnected, &name);
- if( isconnected ){
- printf("name = %s\n", name);
- free(name);
- }else{
- printf("disconnected\n");
- }
- sound_device_e device;
- sound_manager_get_current_sound_device(&device);
- printf("device =%d\n", device);
-
-}
-
-int main()
-{
- if( !g_thread_supported() )
- {
- g_thread_init(NULL);
- }
-
- GError *gerr = NULL;
- event_thread = g_thread_create(GmainThread, NULL, 1, &gerr);
-
-
-
- //set_volume_test();
- //set_policy_test();
- //mm_bug_test();
- //wav_play_test();
- //tone_play_test();
- //wav_play_test();
- session_test();
- //a2dp_test();
- return 0;
-}
--- /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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <sound_manager.h>
+#include <pthread.h>
+#include <glib.h>
+//#include <dlfcn.h>
+
+#define MAX_STRING_LEN 2048
+
+
+enum
+{
+ CURRENT_STATUS_MAINMENU,
+ CURRENT_STATUS_GET_MAX_VOLUME,
+ CURRENT_STATUS_SET_VOLUME,
+ CURRENT_STATUS_GET_VOLUME,
+ CURRENT_STATUS_SET_CURRENT_SOUND_TYPE,
+ CURRENT_STATUS_GET_CURRENT_SOUND_TYPE,
+ CURRENT_STATUS_UNSET_CURRENT_SOUND_TYPE,
+ CURRENT_STATUS_SET_VOLUME_CHANGED_CB,
+ CURRENT_STATUS_UNSET_VOLUME_CHANGED_CB,
+ CURRENT_STATUS_SET_SESSION_TYPE,
+ CURRENT_STATUS_GET_SESSION_TYPE,
+ CURRENT_STATUS_SET_MEDIA_SESSION_OPTION,
+ CURRENT_STATUS_GET_MEDIA_SESSION_OPTION,
+ CURRENT_STATUS_SET_MEDIA_SESSION_RESUMPTION_OPTION,
+ CURRENT_STATUS_GET_MEDIA_SESSION_RESUMPTION_OPTION,
+ CURRENT_STATUS_SET_VOIP_SESSION_MODE,
+ CURRENT_STATUS_GET_VOIP_SESSION_MODE,
+ CURRENT_STATUS_SET_SESSION_INTERRUPTED_CB,
+ CURRENT_STATUS_UNSET_SESSION_INTERRUPTED_CB,
+ CURRENT_STATUS_SET_DEVICE_MASK,
+ CURRENT_STATUS_GET_DEVICE_MASK,
+ CURRENT_STATUS_GET_DEVICE_LIST,
+ CURRENT_STATUS_GET_DEVICE_NEXT,
+ CURRENT_STATUS_GET_DEVICE_PREV,
+ CURRENT_STATUS_SET_DEVICE_CONNECTED_CB,
+ CURRENT_STATUS_UNSET_DEVICE_CONNECTED_CB,
+ CURRENT_STATUS_SET_DEVICE_INFO_CHANGED_CB,
+ CURRENT_STATUS_UNSET_DEVICE_INFO_CHANGED_CB,
+};
+
+
+static int g_menu_state = CURRENT_STATUS_MAINMENU;
+
+GMainLoop* g_loop;
+sound_device_list_h g_device_list = NULL;
+sound_device_mask_e g_device_mask = SOUND_DEVICE_ALL_MASK;
+
+void quit_program()
+{
+ g_main_loop_quit(g_loop);
+}
+
+void _interpret_main_menu(char *cmd)
+{
+ if (strncmp(cmd, "gx", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_GET_MAX_VOLUME;
+ }
+ else if (strncmp(cmd, "sv", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_SET_VOLUME;
+ }
+ else if (strncmp(cmd, "gv", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_GET_VOLUME;
+ }
+ else if (strncmp(cmd, "st", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_SET_CURRENT_SOUND_TYPE;
+ }
+ else if (strncmp(cmd, "gt", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_GET_CURRENT_SOUND_TYPE;
+ }
+ else if (strncmp(cmd, "ut", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_UNSET_CURRENT_SOUND_TYPE;
+ }
+ else if (strncmp(cmd, "vc", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_SET_VOLUME_CHANGED_CB;
+ }
+ else if (strncmp(cmd, "uv", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_UNSET_VOLUME_CHANGED_CB;
+ }
+ else if (strncmp(cmd, "ss", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_SET_SESSION_TYPE;
+ }
+ else if (strncmp(cmd, "gs", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_GET_SESSION_TYPE;
+ }
+ else if (strncmp(cmd, "sm", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_SET_MEDIA_SESSION_OPTION;
+ }
+ else if (strncmp(cmd, "gm", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_GET_MEDIA_SESSION_OPTION;
+ }
+ else if (strncmp(cmd, "sr", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_SET_MEDIA_SESSION_RESUMPTION_OPTION;
+ }
+ else if (strncmp(cmd, "gr", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_GET_MEDIA_SESSION_RESUMPTION_OPTION;
+ }
+ else if (strncmp(cmd, "so", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_SET_VOIP_SESSION_MODE;
+ }
+ else if (strncmp(cmd, "go", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_GET_VOIP_SESSION_MODE;
+ }
+ else if (strncmp(cmd, "sc", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_SET_SESSION_INTERRUPTED_CB;
+ }
+ else if (strncmp(cmd, "us", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_UNSET_SESSION_INTERRUPTED_CB;
+ }
+ else if (strncmp(cmd, "sk", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_SET_DEVICE_MASK;
+ }
+ else if (strncmp(cmd, "gk", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_GET_DEVICE_MASK;
+ }
+ else if (strncmp(cmd, "gl", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_GET_DEVICE_LIST;
+ }
+ else if (strncmp(cmd, "gn", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_GET_DEVICE_NEXT;
+ }
+ else if (strncmp(cmd, "gp", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_GET_DEVICE_PREV;
+ }
+ else if (strncmp(cmd, "sd", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_SET_DEVICE_CONNECTED_CB;
+ }
+ else if (strncmp(cmd, "ud", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_UNSET_DEVICE_CONNECTED_CB;
+ }
+ else if (strncmp(cmd, "si", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_SET_DEVICE_INFO_CHANGED_CB;
+ }
+ else if (strncmp(cmd, "ui", 2) == 0 )
+ {
+ g_menu_state = CURRENT_STATUS_UNSET_DEVICE_INFO_CHANGED_CB;
+ }
+ else if (strncmp(cmd, "q", 1) == 0 )
+ {
+ g_print("closing the test suite\n");
+ quit_program();
+ }
+ else
+ {
+ g_print("unknown menu \n");
+ }
+
+}
+
+void display_sub_basic()
+{
+ g_print("\n");
+ g_print("=========================================================================================\n");
+ g_print(" Sound Manager Test (press q to quit) \n");
+ g_print("-----------------------------------------------------------------------------------------\n");
+ g_print(" VOLUME MODULE \n");
+ g_print("-----------------------------------------------------------------------------------------\n");
+ g_print("gx. Get Max Volume \n");
+ g_print("sv. Set Volume \t");
+ g_print("gv. Get Volume \n");
+ g_print("st. Set Current Sound Type \t");
+ g_print("gt. Get Current Sound Type \t");
+ g_print("ut. Unset Current Sound Type \n");
+ g_print("vc. Set Volume Changed CB \t");
+ g_print("uv. Unset Volume Changed CB \n");
+ g_print("-----------------------------------------------------------------------------------------\n");
+ g_print(" SESSION MODULE \n");
+ g_print("-----------------------------------------------------------------------------------------\n");
+ g_print("ss. Set Session Type\t\t");
+ g_print("gs. Get Session Type\n");
+ g_print("sm. Set Media Session Option \t");
+ g_print("gm. Get Media Session Option \n");
+ g_print("sr. Set Media Session Resumption Option \t");
+ g_print("gr. Get Media Session Resumption Option \n");
+ g_print("so. Set Voip Session Mode \t");
+ g_print("go. Get Voip Session Mode \n");
+ g_print("sc. Set Session Interruped CB \t");
+ g_print("us. Unset Session Interrupted CB \n");
+ g_print("-----------------------------------------------------------------------------------------\n");
+ g_print(" DEVICE MODULE \n");
+ g_print("-----------------------------------------------------------------------------------------\n");
+ g_print("sk. Set Devices Mask(default ALL)\t");
+ g_print("gk. Get Devices Mask\n");
+ g_print("gl. Get Devices List\n");
+ g_print("gn. Get Next Device\t\t");
+ g_print("gp. Get Prev Device\n");
+ g_print("sd. Set Device Connenected CB\t\t");
+ g_print("ud. Unset Device Connenected CB\n");
+ g_print("si. Set Device Information Changed CB\t");
+ g_print("ui. Unset Device Information Changed CB\n");
+ g_print("\n");
+ g_print("=========================================================================================\n");
+}
+
+static void displaymenu()
+{
+ static int flag = 0;
+ if (g_menu_state == CURRENT_STATUS_MAINMENU)
+ {
+ display_sub_basic();
+ flag = 0;
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_MAX_VOLUME)
+ {
+ g_print("*** input sound type(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:VOICE)\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_VOLUME)
+ {
+ if(flag == 0)
+ g_print("*** input sound type and desired volume level(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:VOICE, (0~max volum).\n");
+ flag =1;
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_VOLUME)
+ {
+ g_print("*** input sound type(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:VOICE)\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_CURRENT_SOUND_TYPE)
+ {
+ g_print("*** input sound type.(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:VOICE)\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_CURRENT_SOUND_TYPE)
+ {
+ g_print("*** press enter to get current sound type\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_UNSET_CURRENT_SOUND_TYPE)
+ {
+ g_print("*** press enter to unset current sound type\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_VOLUME_CHANGED_CB)
+ {
+ g_print("*** press enter to set volume changed cb\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_UNSET_VOLUME_CHANGED_CB)
+ {
+ g_print("*** press enter to unset volume changed cb\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_SESSION_TYPE)
+ {
+ g_print("*** input session type(0:MEDIA, 1:ALARM, 2:NOTIFICATION, 3:EMERGENCY, 4:VOIP)\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_SESSION_TYPE)
+ {
+ g_print("*** press enter to get session type\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_MEDIA_SESSION_OPTION)
+ {
+ if(flag == 0)
+ g_print("*** input starting option, and ongoing(for starting(0:MIX WITH OTHERS, 1:PAUSE OTHERS), for ongoing(0:INTERRUPTABLE, 1:UNINTERRUPABLE)\n");
+ flag = 1;
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_MEDIA_SESSION_OPTION)
+ {
+ g_print("*** press enter to get media session option\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_MEDIA_SESSION_RESUMPTION_OPTION)
+ {
+ g_print("*** input media session resumption option(0:BY SYSTEM, 1:OR MEDIA PAUSE)\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_MEDIA_SESSION_RESUMPTION_OPTION)
+ {
+ g_print("*** press enter to get media session resumption option\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_VOIP_SESSION_MODE)
+ {
+ g_print("*** input voip session mode (0:RINGTONE, 1:VOICE with RCV, 2:VOICE with SPK, 3:VOICE with AudioJack, 4:VOICE with BT)\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_VOIP_SESSION_MODE)
+ {
+ g_print("*** press enter to get voip session mode\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_SESSION_INTERRUPTED_CB)
+ {
+ g_print("*** press enter to set session interrupted cb\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_UNSET_SESSION_INTERRUPTED_CB)
+ {
+ g_print("*** press enter to unset session interrupted cb\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_DEVICE_MASK)
+ {
+ g_print("*** input device mask (0:ALL, 1:INTERNAL, 2:EXTERNAL, 3:INPUT, 4:OUTPUT, 5:BOTH, 6:ACTIVATED, 7:DEACTIVATED, b:back to the menu\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_DEVICE_MASK)
+ {
+ g_print("*** press enter to get device mask\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_DEVICE_LIST)
+ {
+ g_print("*** press enter to get device list\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_DEVICE_NEXT)
+ {
+ g_print("*** press enter to get next device from the list\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_GET_DEVICE_PREV)
+ {
+ g_print("*** press enter to get previous device from the list\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_DEVICE_CONNECTED_CB)
+ {
+ g_print("*** press enter to set device connected cb\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_UNSET_DEVICE_CONNECTED_CB)
+ {
+ g_print("*** press enter to unset device connected cb\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_DEVICE_INFO_CHANGED_CB)
+ {
+ g_print("*** press enter to set device information changed cb\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_UNSET_DEVICE_INFO_CHANGED_CB)
+ {
+ g_print("*** press enter to unset device information changed cb\n");
+ }
+ else
+ {
+ g_print("*** unknown status.\n");
+ quit_program();
+ }
+ g_print(" >>> ");
+}
+
+gboolean timeout_menu_display(void* data)
+{
+ displaymenu();
+ return FALSE;
+}
+
+gboolean timeout_quit_program(void* data)
+{
+ //elm_exit();
+ quit_program();
+ return FALSE;
+}
+
+int convert_sound_type(sound_type_e *type, char *cmd)
+{
+ int sound_type_n = atoi(cmd);
+ if (SOUND_TYPE_SYSTEM > sound_type_n || sound_type_n > SOUND_TYPE_VOICE)
+ {
+ g_print("not supported sound type(%d)\n", sound_type_n);
+ return 0;
+ }
+ else
+ {
+ switch (sound_type_n)
+ {
+ case 0:
+ *type = SOUND_TYPE_SYSTEM;
+ break;
+ case 1:
+ *type = SOUND_TYPE_NOTIFICATION;
+ break;
+ case 2:
+ *type = SOUND_TYPE_ALARM;
+ break;
+ case 3:
+ *type = SOUND_TYPE_RINGTONE;
+ break;
+ case 4:
+ *type = SOUND_TYPE_MEDIA;
+ break;
+ case 5:
+ *type = SOUND_TYPE_CALL;
+ break;
+ case 6:
+ *type = SOUND_TYPE_VOIP;
+ break;
+ case 7:
+ *type = SOUND_TYPE_VOICE;
+ break;
+ default:
+ break;
+ }
+ }
+ return 1;
+}
+
+int convert_session_type(sound_session_type_e *type, char *cmd)
+{
+ int session_type_n = atoi(cmd);
+ if (SOUND_SESSION_TYPE_MEDIA > session_type_n || session_type_n > SOUND_SESSION_TYPE_VOIP)
+ {
+ g_print("not supported session type(%d)\n", session_type_n);
+ return 0;
+ }
+ else
+ {
+ switch (session_type_n)
+ {
+ case 0:
+ *type = SOUND_SESSION_TYPE_MEDIA;
+ break;
+ case 1:
+ *type = SOUND_SESSION_TYPE_ALARM;
+ break;
+ case 2:
+ *type = SOUND_SESSION_TYPE_NOTIFICATION;
+ break;
+ case 3:
+ *type = SOUND_SESSION_TYPE_EMERGENCY;
+ break;
+ case 4:
+ *type = SOUND_SESSION_TYPE_VOIP;
+ break;
+ default:
+ break;
+ }
+ }
+ return 1;
+}
+
+void _set_volume_changed_cb(sound_type_e type, unsigned int volume, void *user_data)
+{
+ g_print("***the volume has changed. the volume of this sound type(%d) is : %d \n", type, volume);
+}
+
+void _set_session_interrupted_cb(sound_session_interrupted_code_e code, void *user_data)
+{
+ g_print("***your session has been interrupted by (%d)\n", code);
+}
+
+void _set_device_connected_cb(sound_device_h device, bool is_connected, void *user_data)
+{
+ sound_device_type_e type;
+ sound_device_io_direction_e io_direction;
+ sound_device_state_e state;
+ int id;
+ char *name;
+ int ret = SOUND_MANAGER_ERROR_NONE;
+
+ g_print("***device connected callback is called, is_connected[%d]\n", is_connected);
+
+ if ((ret = sound_manager_get_device_type (device, &type)))
+ g_print("failed to get device type, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_io_direction (device, &io_direction)))
+ g_print("failed to get device io direction, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_id (device, &id)))
+ g_print("failed to get device id, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_name (device, &name)))
+ g_print("failed to get device name, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_state (device, &state)))
+ g_print("failed to get device state, ret[0x%x]\n", ret);
+ if (!ret)
+ g_print(" -- device type[%d], io_direction[%d], id[%d], name[%s], state[%d]\n", type, io_direction, id, name, state);
+}
+
+void _set_device_info_changed_cb(sound_device_h device, sound_device_changed_info_e changed_info, void *user_data)
+{
+ sound_device_type_e type;
+ sound_device_io_direction_e io_direction;
+ sound_device_state_e state;
+ int id;
+ char *name;
+ int ret = SOUND_MANAGER_ERROR_NONE;
+
+ g_print("***device information changed callback is called, changed_info[%d](0:STATE 1:IO_DIRECTION)\n", changed_info);
+
+ if ((ret = sound_manager_get_device_type (device, &type)))
+ g_print("failed to get device type, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_io_direction (device, &io_direction)))
+ g_print("failed to get device io direction, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_id (device, &id)))
+ g_print("failed to get device id, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_name (device, &name)))
+ g_print("failed to get device name, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_state (device, &state)))
+ g_print("failed to get device state, ret[0x%x]\n", ret);
+ if (!ret)
+ g_print(" -- device type[%d], io_direction[%d], id[%d], name[%s], state[%d]\n", type, io_direction, id, name, state);
+}
+
+void reset_menu_state(void)
+{
+ g_menu_state = CURRENT_STATUS_MAINMENU;
+}
+
+static void interpret (char *cmd)
+{
+ switch (g_menu_state)
+ {
+ case CURRENT_STATUS_MAINMENU:
+ {
+ _interpret_main_menu(cmd);
+ }
+ break;
+ case CURRENT_STATUS_GET_MAX_VOLUME:
+ {
+ static sound_type_e type;
+ static int max;
+ if(convert_sound_type(&type,cmd) == 1)
+ {
+ if(sound_manager_get_max_volume(type, &max) != 0)
+ g_print("failt to get max volume\n");
+ else
+ g_print("the max volume of this type(%d) is %d\n", type, max);
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_VOLUME:
+ {
+ static int cnt =0;
+ static sound_type_e type;
+ static int volume;
+ switch(cnt)
+ {
+ case 0:
+ if(convert_sound_type(&type,cmd) == 1)
+ cnt ++;
+ else
+ reset_menu_state();
+ break;
+ case 1:
+ volume = atoi(cmd);
+ if(sound_manager_set_volume(type, volume) != 0)
+ g_print("fail to set volume(%d) check sound type(%d)'s available volume level\n", volume, type);
+ else
+ g_print("set volume success : sound type(%d), volume(%d)\n",type, volume);
+ cnt = 0;
+ reset_menu_state();
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case CURRENT_STATUS_GET_VOLUME:
+ {
+ static sound_type_e type;
+ static int volume;
+ if(convert_sound_type(&type,cmd) == 1)
+ {
+ if(sound_manager_get_volume(type, &volume) != 0)
+ g_print("fail to get volume\n");
+ else
+ g_print("current volume of this type(%d) is : %d\n", type, volume);
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_CURRENT_SOUND_TYPE:
+ {
+ static sound_type_e type;
+ if(convert_sound_type(&type,cmd) == 1)
+ {
+ if(sound_manager_set_current_sound_type(type) != 0)
+ g_print("fail to set sound type(%d)\n", type);
+ else
+ g_print("success to set sound type(%d)\n", type);
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_GET_CURRENT_SOUND_TYPE:
+ {
+ static sound_type_e type;
+ if(sound_manager_get_current_sound_type(&type) !=0)
+ g_print("fail to get current sound type\n");
+ else
+ g_print("current sound type is (%d)\n", type);
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_UNSET_CURRENT_SOUND_TYPE:
+ {
+ if(sound_manager_unset_current_sound_type() !=0)
+ g_print("fail to unset current sound type\n");
+ else
+ g_print("success to unset current sound type\n");
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_VOLUME_CHANGED_CB:
+ {
+ if(sound_manager_set_volume_changed_cb(_set_volume_changed_cb, NULL) !=0)
+ g_print("fail to set volume changed cb\n");
+ else
+ g_print("success to set volume changed cb\n");
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_UNSET_VOLUME_CHANGED_CB:
+ {
+ if(sound_manager_unset_volume_changed_cb() !=0)
+ g_print("fail to unset volume changed cb\n");
+ else
+ g_print("success to unset volume changed cb\n");
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_SESSION_TYPE:
+ {
+ static sound_session_type_e type;
+ if(convert_session_type(&type, cmd) == 1)
+ {
+ if(sound_manager_set_session_type(type) !=0)
+ g_print("fail to set session type\n");
+ else
+ g_print("success to set session type(%d)\n",type);
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_GET_SESSION_TYPE:
+ {
+ static sound_session_type_e type;
+ if(sound_manager_get_session_type(&type) !=0)
+ g_print("fail to get session type\n");
+ else
+ g_print("current session type is : %d (0:MEDIA, 1:ALARM, 2:NOTIFICATION, 3:EMERGENCY, 4:VOIP)\n", type);
+
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_MEDIA_SESSION_OPTION:
+ {
+ static sound_session_type_e type = SOUND_SESSION_TYPE_MEDIA;
+ static sound_session_option_for_starting_e option_s;
+ static sound_session_option_for_during_play_e option_d;
+ static int cnt = 0;
+ if(sound_manager_set_session_type(type) !=0)
+ {
+ g_print("fail to set media session type\n");
+ reset_menu_state();
+ }
+ else
+ {
+ switch(cnt)
+ {
+ case 0:
+ option_s = (sound_session_option_for_starting_e)atoi(cmd);
+ if(SOUND_SESSION_OPTION_MIX_WITH_OTHERS_WHEN_START > option_s || SOUND_SESSION_OPTION_PAUSE_OTHERS_WHEN_START < option_s)
+ g_print("not supported option type\n");
+ else
+ cnt ++;
+ break;
+ case 1:
+ option_d = (sound_session_option_for_during_play_e)atoi(cmd);
+ if(SOUND_SESSION_OPTION_INTERRUPTIBLE_DURING_PLAY > option_d || SOUND_SESSION_OPTION_UNINTERRUPTIBLE_DURING_PLAY < option_d)
+ g_print("not supported option type\n");
+ else
+ {
+ if(sound_manager_set_media_session_option(option_s, option_d) != 0)
+ g_print("fail to set media session option\n");
+ else
+ g_print("success to set media session option\n");
+ cnt = 0;
+ }
+ reset_menu_state();
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ break;
+ case CURRENT_STATUS_GET_MEDIA_SESSION_OPTION:
+ {
+ static sound_session_type_e type = SOUND_SESSION_TYPE_MEDIA;
+ static sound_session_option_for_starting_e option_s;
+ static sound_session_option_for_during_play_e option_d;
+ if(sound_manager_set_session_type(type) != 0)
+ g_print("fail to set media session type\n");
+ else
+ {
+ if(sound_manager_get_media_session_option(&option_s,&option_d) !=0)
+ g_print("fail to get media session option\n");
+ else
+ g_print("current media session options are (%d) for starting, (%d) for ongoing\n", option_s, option_d);
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_MEDIA_SESSION_RESUMPTION_OPTION:
+ {
+ static sound_session_type_e type = SOUND_SESSION_TYPE_MEDIA;
+ static sound_session_option_for_resumption_e option_r;
+ if(sound_manager_set_session_type(type) != 0)
+ g_print("fail to set media session type\n");
+ else
+ {
+ option_r = (sound_session_option_for_resumption_e)atoi(cmd);
+ if(SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM > option_r || SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM_OR_MEDIA_PAUSED < option_r)
+ g_print("not supported option type\n");
+ else
+ {
+ if(sound_manager_set_media_session_resumption_option(option_r) !=0)
+ g_print("fail to set media session resumption option\n");
+ else
+ g_print("succese to set media session resumption option\n");
+ }
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_GET_MEDIA_SESSION_RESUMPTION_OPTION:
+ {
+ static sound_session_type_e type = SOUND_SESSION_TYPE_MEDIA;
+ static sound_session_option_for_resumption_e option_r;
+ if(sound_manager_set_session_type(type) != 0)
+ g_print("fail to set media session type\n");
+ else
+ {
+ if(sound_manager_get_media_session_resumption_option(&option_r) != 0)
+ g_print("fail to get media session resumption option\n");
+ else
+ g_print("current media session resumption option is : %d\n", option_r);
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_VOIP_SESSION_MODE:
+ {
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ sound_session_voip_mode_e mode;
+ mode = (sound_session_voip_mode_e)atoi(cmd);
+ ret = sound_manager_set_voip_session_mode(mode);
+ if (ret) {
+ g_print("failed to set voip session mode(%d), ret[0x%x]\n", mode, ret);
+ } else {
+ g_print("success to set voip session mode\n");
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_GET_VOIP_SESSION_MODE:
+ {
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ sound_session_voip_mode_e mode;
+ ret = sound_manager_get_voip_session_mode(&mode);
+ if(ret)
+ g_print("fail to get voip session mode, ret[0x%x]\n", ret);
+ else
+ g_print("success to get voip session mode, mode[%d]\n", mode);
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_SESSION_INTERRUPTED_CB:
+ {
+ if(sound_manager_set_session_interrupted_cb(_set_session_interrupted_cb, NULL) != 0)
+ g_print("fail to set interrupted changed cb\n");
+ else
+ g_print("success to set interrupted changed cb\n");
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_UNSET_SESSION_INTERRUPTED_CB:
+ {
+ if(sound_manager_unset_session_interrupted_cb() != 0)
+ g_print("fail to unset interrupted changed cb\n");
+ else
+ g_print("success to unset interrupted changed cb\n");
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_DEVICE_MASK:
+ {
+ if (strncmp(cmd, "0", 1) == 0) {
+ g_device_mask = SOUND_DEVICE_ALL_MASK;
+ reset_menu_state();
+ } else if (strncmp(cmd, "1", 1) == 0) {
+ if (g_device_mask == SOUND_DEVICE_ALL_MASK)
+ g_device_mask = SOUND_DEVICE_TYPE_INTERNAL_MASK;
+ else
+ g_device_mask |= SOUND_DEVICE_TYPE_INTERNAL_MASK;
+ g_print("add TYPE_INTERNAL MASK\n");
+ } else if (strncmp(cmd, "2", 1) == 0) {
+ if (g_device_mask == SOUND_DEVICE_ALL_MASK)
+ g_device_mask = SOUND_DEVICE_TYPE_EXTERNAL_MASK;
+ else
+ g_device_mask |= SOUND_DEVICE_TYPE_EXTERNAL_MASK;
+ g_print("add TYPE_EXTERNAL MASK\n");
+ } else if (strncmp(cmd, "3", 1) == 0) {
+ if (g_device_mask == SOUND_DEVICE_ALL_MASK)
+ g_device_mask = SOUND_DEVICE_IO_DIRECTION_IN_MASK;
+ else
+ g_device_mask |= SOUND_DEVICE_IO_DIRECTION_IN_MASK;
+ g_print("add IO_DIRECTION_IN MASK\n");
+ } else if (strncmp(cmd, "4", 1) == 0) {
+ if (g_device_mask == SOUND_DEVICE_ALL_MASK)
+ g_device_mask = SOUND_DEVICE_IO_DIRECTION_OUT_MASK;
+ else
+ g_device_mask |= SOUND_DEVICE_IO_DIRECTION_OUT_MASK;
+ g_print("add IO_DIRECTION_OUT MASK\n");
+ } else if (strncmp(cmd, "5", 1) == 0) {
+ if (g_device_mask == SOUND_DEVICE_ALL_MASK)
+ g_device_mask = SOUND_DEVICE_IO_DIRECTION_BOTH_MASK;
+ else
+ g_device_mask |= SOUND_DEVICE_IO_DIRECTION_BOTH_MASK;
+ g_print("add IO_DIRECTION_BOTH MASK\n");
+ } else if (strncmp(cmd, "6", 1) == 0) {
+ if (g_device_mask == SOUND_DEVICE_ALL_MASK)
+ g_device_mask = SOUND_DEVICE_STATE_ACTIVATED_MASK;
+ else
+ g_device_mask |= SOUND_DEVICE_STATE_ACTIVATED_MASK;
+ g_print("add STATE_ACTIVATED MASK\n");
+ } else if (strncmp(cmd, "7", 1) == 0) {
+ if (g_device_mask == SOUND_DEVICE_ALL_MASK)
+ g_device_mask = SOUND_DEVICE_STATE_DEACTIVATED_MASK;
+ else
+ g_device_mask |= SOUND_DEVICE_STATE_DEACTIVATED_MASK;
+ g_print("add STATE_DEACTIVATED MASK\n");
+ } else if (strncmp(cmd, "b", 1) == 0) {
+ g_print("device mask[0x%x]\n", g_device_mask);
+ reset_menu_state();
+ } else {
+ g_print("invalid selection, please select again..\n");
+ }
+ }
+ break;
+ case CURRENT_STATUS_GET_DEVICE_MASK:
+ {
+ g_print("current device mask[0x%x]\n", g_device_mask);
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_GET_DEVICE_LIST:
+ {
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ if (!(ret = sound_manager_get_current_device_list(g_device_mask, &g_device_list)))
+ g_print("success to get current device list\n");
+ else
+ g_print("fail to get current device list, ret[0x%x]\n", ret);
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_GET_DEVICE_NEXT:
+ {
+ sound_device_h device;
+ sound_device_type_e type;
+ sound_device_io_direction_e io_direction;
+ sound_device_state_e state;
+ int id;
+ char *name;
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ if (!(ret = sound_manager_get_next_device(g_device_list, &device))) {
+ g_print("success to get next device\n");
+ if ((ret = sound_manager_get_device_type (device, &type)))
+ g_print("failed to get device type, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_io_direction (device, &io_direction)))
+ g_print("failed to get device io direction, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_id (device, &id)))
+ g_print("failed to get device id, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_name (device, &name)))
+ g_print("failed to get device name, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_state (device, &state)))
+ g_print("failed to get device state, ret[0x%x]\n", ret);
+ if (!ret)
+ g_print("-- NEXT device type[%d], io_direction[%d], id[%d], name[%s], state[%d]\n", type, io_direction, id, name, state);
+ } else {
+ g_print("failed to get next device, ret[0x%x]\n", ret);
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_GET_DEVICE_PREV:
+ {
+ sound_device_h device;
+ sound_device_type_e type;
+ sound_device_io_direction_e io_direction;
+ sound_device_state_e state;
+ int id;
+ char *name;
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ if (!(ret = sound_manager_get_prev_device(g_device_list, &device))) {
+ g_print("success to get previous device\n");
+ if ((ret = sound_manager_get_device_type (device, &type)))
+ g_print("failed to get device type, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_io_direction (device, &io_direction)))
+ g_print("failed to get device io direction, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_id (device, &id)))
+ g_print("failed to get device id, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_name (device, &name)))
+ g_print("failed to get device name, ret[0x%x]\n", ret);
+ if ((ret = sound_manager_get_device_state (device, &state)))
+ g_print("failed to get device state, ret[0x%x]\n", ret);
+ if (!ret)
+ g_print("-- PREV device type[%d], io_direction[%d], id[%d], name[%s], state[%d]\n", type, io_direction, id, name, state);
+ } else {
+ g_print("failed to get previous device, ret[0x%x]\n", ret);
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_DEVICE_CONNECTED_CB:
+ {
+ if (sound_manager_set_device_connected_cb(g_device_mask, _set_device_connected_cb, NULL))
+ g_print("fail to set device connected cb\n");
+ else
+ g_print("success to set device connected cb\n");
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_UNSET_DEVICE_CONNECTED_CB:
+ {
+ if (sound_manager_unset_device_connected_cb())
+ g_print("fail to unset device connected cb\n");
+ else
+ g_print("success to unset device connected cb\n");
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_SET_DEVICE_INFO_CHANGED_CB:
+ {
+ if (sound_manager_set_device_information_changed_cb(g_device_mask, _set_device_info_changed_cb, NULL))
+ g_print("fail to set device information changed cb\n");
+ else
+ g_print("success to set device information changed cb\n");
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_UNSET_DEVICE_INFO_CHANGED_CB:
+ {
+ if (sound_manager_unset_device_information_changed_cb())
+ g_print("fail to unset device information changed cb\n");
+ else
+ g_print("success to unset device information changed cb\n");
+ reset_menu_state();
+ }
+ break;
+ }
+ g_timeout_add(100, timeout_menu_display, 0);
+}
+
+gboolean input (GIOChannel *channel)
+{
+ gchar buf[MAX_STRING_LEN];
+ gsize read;
+ GError *error = NULL;
+
+ g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
+ buf[read] = '\0';
+ g_strstrip(buf);
+ interpret (buf);
+
+ return TRUE;
+}
+
+int main(int argc, char *argv[])
+{
+ GIOChannel *stdin_channel;
+ stdin_channel = g_io_channel_unix_new(0);
+ g_io_channel_set_flags (stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
+ g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
+ g_loop = g_main_loop_new (NULL, 1);
+
+ displaymenu();
+ g_main_loop_run (g_loop);
+
+ return 0;
+}
projects / platform / core / api / sound-manager.git / commitdiff