wearable/include/audio-session-manager-types.h

   1 /*
   2  * audio-session-manager
   3  *
   4  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Seungbae Shin <seungbae.shin at samsung.com>, Sangchul Lee <sc11.lee at samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #ifndef _ASM_TYPES_H_
  23 #define _ASM_TYPES_H_
  24
  25 /**
  26  * @ingroup  AUDIO_SESSION_MANAGER
  27  * @defgroup AUDIO_SESSION_MANAGER Audio Session Manager
  28  * @{
  29  */
  30 #include <stdbool.h>
  31
  32 /* Error codes */
  33 #define ERR_ASM_ERROR_NONE                     0x00
  34 #define ERR_ASM_THREAD_CREATE_ERROR            0x01
  35 #define ERR_ASM_THREAD_CANCEL_ERROR            0x02
  36 #define ERR_ASM_MSG_QUEUE_MSGID_GET_FAILED     0x03
  37 #define ERR_ASM_MSG_QUEUE_SND_ERROR            0x04
  38 #define ERR_ASM_MSG_QUEUE_RCV_ERROR            0x05
  39 #define ERR_ASM_ALREADY_REGISTERED             0x06
  40 #define ERR_ASM_ALREADY_UNREGISTERED           0x07
  41 #define ERR_ASM_EVENT_IS_INVALID               0x08
  42 #define ERR_ASM_LOCAL_HANDLE_IS_FULL           0x09
  43 #define ERR_ASM_POLICY_CANNOT_PLAY             0x10
  44 #define ERR_ASM_POLICY_CANNOT_PLAY_BY_CALL     0x11 /* CALL / VIDEOCALL / RICH_CALL */
  45 #define ERR_ASM_POLICY_CANNOT_PLAY_BY_ALARM    0x12
  46 #define ERR_ASM_POLICY_CANNOT_PLAY_BY_PROFILE  0x13 /* blocked by sound profile */
  47 #define ERR_ASM_POLICY_CANNOT_PLAY_BY_CUSTOM   0x14 /* blocked by custom reason */
  48 #define ERR_ASM_POLICY_INVALID_HANDLE          0x1f
  49 #define ERR_ASM_INVALID_PARAMETER              0x20
  50 #define ERR_ASM_VCONF_ERROR                    0x21
  51 #define ERR_ASM_NOT_SUPPORTED                  0x22
  52 #define ERR_ASM_NO_OPERATION                   0x23
  53 #define ERR_ASM_UNKNOWN_ERROR                  0x2F
  54 #define ERR_ASM_SERVER_HANDLE_IS_FULL          0x30
  55 #define ERR_ASM_WATCH_ALREADY_REQUESTED        0x40
  56 #define ERR_ASM_WATCH_ALREADY_UNREQUESTED      0x41
  57 #define ERR_ASM_WATCH_NOT_SUPPORTED            0x42
  58 #define ERR_ASM_ADD_WATCH_LIST_FAILURE         0x43
  59 #define ERR_ASM_DEL_WATCH_LIST_FAILURE         0x44
  60 #ifdef USE_SECURITY
  61 #define ERR_ASM_CHECK_PRIVILEGE_FAILED         0x40
  62 #define COOKIE_SIZE                             20
  63 #endif
  64
  65
  66 #define ASM_PRIORITY_MATRIX_MIN (ASM_EVENT_MAX-1)
  67 #define ASM_PRIORITY_SUB_MATRIX_MIN (ASM_SUB_EVENT_MAX-1)
  68 #define ASM_SERVER_HANDLE_MAX 256
  69 #define ASM_HANDLE_INIT_VAL -1
  70
  71 #define SOUND_STATUS_KEY                "memory/Sound/SoundStatus"
  72 /**
  73   * This enumeration defines sound request.
  74   */
  75 typedef enum
  76 {
  77         ASM_REQUEST_REGISTER            = 0,
  78         ASM_REQUEST_UNREGISTER,
  79         ASM_REQUEST_GETSTATE,
  80         ASM_REQUEST_GETMYSTATE,
  81         ASM_REQUEST_SETSTATE,
  82         ASM_REQUEST_EMERGENT_EXIT,
  83         ASM_REQUEST_DUMP,
  84         ASM_REQUEST_SET_SUBSESSION,
  85         ASM_REQUEST_GET_SUBSESSION,
  86         ASM_REQUEST_REGISTER_WATCHER,
  87         ASM_REQUEST_UNREGISTER_WATCHER,
  88         ASM_REQUEST_SET_SUBEVENT,
  89         ASM_REQUEST_GET_SUBEVENT,
  90         ASM_REQUEST_RESET_RESUME_TAG,
  91 } ASM_requests_t;
  92
  93 /**
  94   * This enumeration defines sound event for Sound Scenario in Multimedia Resources Conflict Manager.
  95   */
  96 typedef enum
  97 {
  98         ASM_EVENT_NONE = -1,             // [Notice] Don't use it in application (Never use it), it is internal sound event
  99         ASM_EVENT_SHARE_MMPLAYER = 0,
 100         ASM_EVENT_SHARE_MMCAMCORDER,     // It'll be deprecated
 101         ASM_EVENT_SHARE_MMSOUND,
 102         ASM_EVENT_SHARE_OPENAL,
 103         ASM_EVENT_SHARE_AVSYSTEM,
 104         ASM_EVENT_EXCLUSIVE_MMPLAYER,
 105         ASM_EVENT_EXCLUSIVE_MMCAMCORDER, // It'll be deprecated
 106         ASM_EVENT_EXCLUSIVE_MMSOUND,
 107         ASM_EVENT_EXCLUSIVE_OPENAL,
 108         ASM_EVENT_EXCLUSIVE_AVSYSTEM,
 109         ASM_EVENT_NOTIFY,
 110         ASM_EVENT_CALL,
 111         ASM_EVENT_SHARE_FMRADIO,
 112         ASM_EVENT_EXCLUSIVE_FMRADIO,
 113         ASM_EVENT_EARJACK_UNPLUG,
 114         ASM_EVENT_ALARM,
 115         ASM_EVENT_VIDEOCALL,
 116         ASM_EVENT_VOIP,
 117         ASM_EVENT_MONITOR,
 118         ASM_EVENT_RICH_CALL,
 119         ASM_EVENT_EMERGENCY,
 120         ASM_EVENT_EXCLUSIVE_RESOURCE,
 121         ASM_EVENT_VOICE_RECOGNITION,
 122         ASM_EVENT_MMCAMCORDER_AUDIO,
 123         ASM_EVENT_MMCAMCORDER_VIDEO,
 124         ASM_EVENT_MAX
 125 } ASM_sound_events_t;
 126
 127 typedef enum
 128 {
 129         ASM_SUB_EVENT_NONE = 0,
 130         ASM_SUB_EVENT_SHARE,
 131         ASM_SUB_EVENT_EXCLUSIVE,
 132         ASM_SUB_EVENT_MAX
 133 } ASM_sound_sub_events_t;
 134
 135 typedef enum {
 136         ASM_SUB_SESSION_TYPE_VOICE = 0,
 137         ASM_SUB_SESSION_TYPE_RINGTONE,
 138         ASM_SUB_SESSION_TYPE_MEDIA,
 139         ASM_SUB_SESSION_TYPE_VOICE_ANSWER_PLAY,
 140         ASM_SUB_SESSION_TYPE_VOICE_ANSWER_REC,
 141         ASM_SUB_SESSION_TYPE_INIT,
 142         ASM_SUB_SESSION_TYPE_VR_NORMAL,
 143         ASM_SUB_SESSION_TYPE_VR_DRIVE,
 144         ASM_SUB_SESSION_TYPE_RECORD_STEREO,
 145         ASM_SUB_SESSION_TYPE_RECORD_STEREO_FOR_INTERVIEW,     /* directional stereo recording for interview */
 146         ASM_SUB_SESSION_TYPE_RECORD_STEREO_FOR_CONVERSATION,  /* directional stereo recording for conversation */
 147         ASM_SUB_SESSION_TYPE_RECORD_MONO,
 148         ASM_SUB_SESSION_TYPE_MAX
 149 } ASM_sound_sub_sessions_t;
 150
 151 /*
 152  * This enumeration defines event source for sound conflict scenario
 153  */
 154 typedef enum
 155 {
 156         ASM_EVENT_SOURCE_MEDIA = 0,
 157         ASM_EVENT_SOURCE_CALL_START,
 158         ASM_EVENT_SOURCE_EARJACK_UNPLUG,
 159         ASM_EVENT_SOURCE_RESOURCE_CONFLICT,
 160         ASM_EVENT_SOURCE_ALARM_START,
 161         ASM_EVENT_SOURCE_ALARM_END,
 162         ASM_EVENT_SOURCE_EMERGENCY_START,
 163         ASM_EVENT_SOURCE_EMERGENCY_END,
 164         ASM_EVENT_SOURCE_OTHER_PLAYER_APP,
 165         ASM_EVENT_SOURCE_RESUMABLE_MEDIA,
 166         ASM_EVENT_SOURCE_NOTIFY_START,
 167         ASM_EVENT_SOURCE_NOTIFY_END,
 168         ASM_EVENT_SOURCE_VR_START,      /* VoiceRecognition Start */
 169         ASM_EVENT_SOURCE_VR_END,        /* VoiceRecognition End */
 170 } ASM_event_sources_t;
 171
 172 /**
 173   * This enumeration defines sound case between playing sound and request sound
 174   * ALTER_PLAY : DTMF tone
 175   */
 176 typedef enum
 177 {
 178         ASM_CASE_NONE                                   = 0,
 179         ASM_CASE_1PLAY_2STOP                    = 1,
 180         ASM_CASE_1STOP_2PLAY                    = 5,
 181         ASM_CASE_1PAUSE_2PLAY                   = 6,
 182         ASM_CASE_1PLAY_2PLAY_MIX                = 8,
 183         ASM_CASE_RESOURCE_CHECK                 = 9,
 184         ASM_CASE_SUB_EVENT                      = 7
 185 } ASM_sound_cases_t;
 186
 187
 188 /*
 189  * This enumeration defines Sound Playing Status Information
 190  * Each bit is Sound Status Type( 0 : None , 1 : Playing)
 191  */
 192 typedef enum
 193 {
 194         ASM_STATUS_NONE                                         = 0x00000000,
 195         ASM_STATUS_SHARE_MMPLAYER                       = 0x00000001,
 196         ASM_STATUS_SHARE_MMCAMCORDER            = 0x00000002,  // It'll be deprecated
 197         ASM_STATUS_SHARE_MMSOUND                        = 0x00000004,
 198         ASM_STATUS_SHARE_OPENAL                         = 0x00000008,
 199         ASM_STATUS_SHARE_AVSYSTEM                       = 0x00000010,
 200         ASM_STATUS_EXCLUSIVE_MMPLAYER           = 0x00000020,
 201         ASM_STATUS_EXCLUSIVE_MMCAMCORDER        = 0x00000040,  // It'll be deprecated
 202         ASM_STATUS_EXCLUSIVE_MMSOUND            = 0x00000080,
 203         ASM_STATUS_EXCLUSIVE_OPENAL                     = 0x00000100,
 204         ASM_STATUS_EXCLUSIVE_AVSYSTEM           = 0x00000200,
 205         ASM_STATUS_NOTIFY                                       = 0x00000400,
 206         ASM_STATUS_CALL                                         = 0x10000000,
 207         ASM_STATUS_SHARE_FMRADIO                        = 0x00000800,
 208         ASM_STATUS_EXCLUSIVE_FMRADIO            = 0x00001000,
 209         ASM_STATUS_EARJACK_UNPLUG                       = 0x00002000,
 210         ASM_STATUS_ALARM                                        = 0x00100000,
 211         ASM_STATUS_VIDEOCALL                            = 0x20000000,
 212         ASM_STATUS_VOIP                                         = 0x00010000,
 213         ASM_STATUS_MONITOR                                      = 0x80000000,
 214         ASM_STATUS_RICH_CALL                            = 0x40000000,
 215         ASM_STATUS_EMERGENCY                            = 0x00004000,
 216         ASM_STATUS_EXCLUSIVE_RESOURCE           = 0x00008000,
 217         ASM_STATUS_VOICE_RECOGNITION            = 0x00020000,
 218         ASM_STATUS_MMCAMCORDER_AUDIO            = 0x00040000,
 219         ASM_STATUS_MMCAMCORDER_VIDEO            = 0x00080000
 220 } ASM_sound_status_t;
 221
 222
 223 /**
 224   * This enumeration defines sound state.
 225   */
 226 typedef enum
 227 {
 228         ASM_STATE_NONE                  = 0,
 229         ASM_STATE_PLAYING                       = 1,
 230         ASM_STATE_WAITING                       = 2,
 231         ASM_STATE_STOP                  = 3,
 232         ASM_STATE_PAUSE                 = 4,
 233         ASM_STATE_PAUSE_BY_APP  = 5,
 234         ASM_STATE_IGNORE                        = 6,
 235 } ASM_sound_states_t;
 236
 237
 238 /*
 239  * This enumeration defines resume state
 240  */
 241 typedef enum
 242 {
 243         ASM_NEED_NOT_RESUME = 0,
 244         ASM_NEED_RESUME = 1,
 245 }ASM_resume_states_t;
 246 /*
 247  * This enumeration defines state return of client.
 248  */
 249 typedef enum
 250 {
 251         ASM_CB_RES_IGNORE       = -1,
 252         ASM_CB_RES_NONE         = 0,
 253         ASM_CB_RES_PLAYING      = 1,
 254         ASM_CB_RES_STOP         = 2,
 255         ASM_CB_RES_PAUSE        = 3,
 256 }ASM_cb_result_t;
 257
 258 /*
 259  * This enumeration defines type of multimedia resource
 260  */
 261
 262 typedef enum
 263 {
 264         ASM_RESOURCE_NONE                               = 0x0000,
 265         ASM_RESOURCE_CAMERA                             = 0x0001,
 266         ASM_RESOURCE_VIDEO_OVERLAY              = 0x0002,
 267         ASM_RESOURCE_STREAMING                  = 0x0004,
 268         ASM_RESOURCE_HW_DECODER                 = 0x0100,
 269         ASM_RESOURCE_HW_ENCODER                 = 0x0200,
 270         ASM_RESOURCE_RADIO_TUNNER               = 0x1000,
 271         ASM_RESOURCE_TV_TUNNER                  = 0x2000,
 272         ASM_RESOURCE_EAR_SPK_PATH               = 0x4000,
 273         ASM_RESOURCE_SVR                                        = 0x8000,
 274         ASM_RESOURCE_VOICECONTROL               = 0x10000,
 275         ASM_RESOURCE_RESUMPTION_TAG             = 0x20000,
 276         ASM_RESOURCE_IOPRIORITY                 = 0x40000,
 277 }ASM_resource_t;
 278
 279
 280 /* Sound command for applications */
 281 typedef enum
 282 {
 283         ASM_COMMAND_NONE                = 0x0,
 284         ASM_COMMAND_PLAY                = 0x2,
 285         ASM_COMMAND_STOP                = 0x3,
 286         ASM_COMMAND_PAUSE               = 0x4,
 287         ASM_COMMAND_RESUME              = 0x5,
 288 } ASM_sound_commands_t;
 289
 290
 291 /* Sound blocking reason for applications */
 292 typedef enum
 293 {
 294         ASM_SOUND_BLOCKED_BY_TABLE         = 0x0, /* blocked by main table */
 295         ASM_SOUND_BLOCKED_BY_SOUND_PROFILE = 0x1, /* blocked by sound profile */
 296         ASM_SOUND_BLOCKED_BY_CUSTOM        = 0x2, /* blocked by custom reason */
 297 } ASM_sound_blocked_reason_t;
 298
 299
 300 /**
 301   * This structure defines the message data from library to conflict manager.
 302   */
 303 typedef struct
 304 {
 305         int                                     handle;
 306         ASM_requests_t                          request_id;
 307         ASM_sound_events_t                      sound_event;
 308         ASM_sound_states_t                      sound_state;
 309         ASM_resource_t                          system_resource;
 310 #ifdef USE_SECURITY
 311         unsigned char   cookie [COOKIE_SIZE];
 312 #endif
 313 } __ASM_msg_data_lib_to_asm_t;
 314
 315 /**
 316   * This structure defines the message data from conflict manager to library.
 317   */
 318 typedef struct
 319 {
 320         int                                     alloc_handle;
 321         int                                     cmd_handle;
 322         ASM_sound_commands_t                    result_sound_command;
 323         ASM_sound_states_t                      result_sound_state;
 324         ASM_sound_events_t                      previous_sound_event;
 325         ASM_sound_blocked_reason_t      reason_of_blocking;
 326         ASM_requests_t                          source_request_id;
 327 #ifdef USE_SECURITY
 328         int                                     check_privilege;
 329 #endif
 330 } __ASM_msg_data_asm_to_lib_t;
 331
 332 /**
 333   * This structure defines the message data from conflict manager to library.
 334   */
 335 typedef struct
 336 {
 337         int                                             handle;
 338         ASM_sound_commands_t      result_sound_command;
 339 } __ASM_msg_data_asm_to_cb_t;
 340
 341 /**
 342   * This structure defines the message from library to conflict manager.
 343   */
 344 typedef struct
 345 {
 346         long int                        instance_id;
 347         __ASM_msg_data_lib_to_asm_t    data;
 348 } ASM_msg_lib_to_asm_t;
 349
 350 /**
 351   * This structure defines the message from conflict manager to library.
 352   */
 353 typedef struct
 354 {
 355         long int                        instance_id;
 356         __ASM_msg_data_asm_to_lib_t     data;
 357 } ASM_msg_asm_to_lib_t;
 358
 359 /**
 360   * This structure defines the message from conflict manager to library.
 361   */
 362 typedef struct
 363 {
 364         long int                                instance_id;
 365         __ASM_msg_data_asm_to_cb_t     data;
 366 } ASM_msg_asm_to_cb_t;
 367
 368
 369 typedef struct
 370 {
 371         ASM_sound_events_t              sound_event;
 372         ASM_sound_status_t              sound_status;
 373 }ASM_sound_event_type_t;
 374
 375
 376 static const ASM_sound_event_type_t ASM_sound_type[] = {
 377     { ASM_EVENT_NONE,                                   ASM_STATUS_NONE },
 378     { ASM_EVENT_SHARE_MMPLAYER,                         ASM_STATUS_SHARE_MMPLAYER },
 379     { ASM_EVENT_SHARE_MMCAMCORDER,              ASM_STATUS_SHARE_MMCAMCORDER },
 380     { ASM_EVENT_SHARE_MMSOUND,                  ASM_STATUS_SHARE_MMSOUND },
 381     { ASM_EVENT_SHARE_OPENAL,                   ASM_STATUS_SHARE_OPENAL },
 382     { ASM_EVENT_SHARE_AVSYSTEM,                         ASM_STATUS_SHARE_AVSYSTEM },
 383     { ASM_EVENT_EXCLUSIVE_MMPLAYER,             ASM_STATUS_EXCLUSIVE_MMPLAYER },
 384     { ASM_EVENT_EXCLUSIVE_MMCAMCORDER,  ASM_STATUS_EXCLUSIVE_MMCAMCORDER },
 385     { ASM_EVENT_EXCLUSIVE_MMSOUND,              ASM_STATUS_EXCLUSIVE_MMSOUND },
 386     { ASM_EVENT_EXCLUSIVE_OPENAL,               ASM_STATUS_EXCLUSIVE_OPENAL },
 387     { ASM_EVENT_EXCLUSIVE_AVSYSTEM,             ASM_STATUS_EXCLUSIVE_AVSYSTEM },
 388     { ASM_EVENT_NOTIFY,                                 ASM_STATUS_NOTIFY },
 389     { ASM_EVENT_CALL,                                   ASM_STATUS_CALL },
 390     { ASM_EVENT_SHARE_FMRADIO,                  ASM_STATUS_SHARE_FMRADIO },
 391     { ASM_EVENT_EXCLUSIVE_FMRADIO,              ASM_STATUS_EXCLUSIVE_FMRADIO },
 392     { ASM_EVENT_EARJACK_UNPLUG,                 ASM_STATUS_EARJACK_UNPLUG },
 393     { ASM_EVENT_ALARM,                                  ASM_STATUS_ALARM },
 394     { ASM_EVENT_VIDEOCALL,                              ASM_STATUS_VIDEOCALL },
 395     { ASM_EVENT_VOIP,                                   ASM_STATUS_VOIP },
 396     { ASM_EVENT_MONITOR,                                ASM_STATUS_MONITOR },
 397     { ASM_EVENT_RICH_CALL,                              ASM_STATUS_RICH_CALL },
 398     { ASM_EVENT_EMERGENCY,                              ASM_STATUS_EMERGENCY },
 399     { ASM_EVENT_EXCLUSIVE_RESOURCE,             ASM_STATUS_EXCLUSIVE_RESOURCE },
 400     { ASM_EVENT_VOICE_RECOGNITION,              ASM_STATUS_VOICE_RECOGNITION },
 401     { ASM_EVENT_MMCAMCORDER_AUDIO,              ASM_STATUS_MMCAMCORDER_AUDIO },
 402     { ASM_EVENT_MMCAMCORDER_VIDEO,              ASM_STATUS_MMCAMCORDER_VIDEO }
 403 };
 404
 405
 406 /**
 407  * This callback function is called when sound status of other sound event is changed
 408  *
 409  * @return                                                      No return value
 410  * @param[in]   sound_status            Argument passed when callback was set
 411  */
 412 typedef ASM_cb_result_t (*ASM_sound_cb_t) (int handle, ASM_event_sources_t event_source, ASM_sound_commands_t command, unsigned int sound_status, void* cb_data);
 413
 414
 415 /**
 416  * This callback function is called when sound status of other sound event and state that you want to watch is changed
 417  *
 418  * @return                                                      No return value
 419  * @param[in]   sound_status            Argument passed when callback was set
 420  */
 421 typedef ASM_cb_result_t (*ASM_watch_cb_t) (int handle, ASM_sound_events_t sound_event, ASM_sound_states_t sound_state, void* cb_data);
 422
 423 #endif