src/mm_player_asm.c

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>, YoungHwan An <younghwan_.an@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 #include <glib.h>
  23 #include <mm_debug.h>
  24 #include "mm_player_priv.h"
  25 #include "mm_player_asm.h"
  26
  27 static ASM_sound_events_t __mmplayer_asm_get_event_type(gint type);
  28
  29 gint
  30 _mmplayer_asm_register(MMPlayerASM* sm, ASM_sound_cb_t callback, void* param)
  31 {
  32         /* read mm-session type */
  33         gint sessionType = MM_SESSION_TYPE_SHARE;
  34         gint errorcode = MM_ERROR_NONE;
  35         gint asm_handle = -1;
  36         gint event_type = ASM_EVENT_NONE;
  37         gint pid = -1;
  38
  39         debug_log("\n");
  40
  41         if ( ! sm )
  42         {
  43                 debug_error("invalid session handle\n");
  44                 return MM_ERROR_PLAYER_NOT_INITIALIZED;
  45         }
  46
  47         /* check if it's running on the media_server */
  48         if ( sm->pid > 0 )
  49         {
  50                 pid = sm->pid;
  51                 debug_log("mm-player is running on different process. Just faking pid to [%d]. :-p\n", pid);
  52         }
  53         else
  54         {
  55                 debug_log("no pid has assigned. using default(current) context\n");
  56         }
  57
  58         /* read session type */
  59         errorcode = _mm_session_util_read_type(pid, &sessionType);
  60         if ( errorcode )
  61         {
  62                 debug_warning("Read MMSession Type failed. use default \"share\" type\n");
  63                 sessionType = MM_SESSION_TYPE_SHARE;
  64
  65                 /* init session */
  66                 errorcode = mm_session_init(sessionType);
  67                 if ( errorcode )
  68                 {
  69                                 debug_critical("mm_session_init() failed\n");
  70                                 return errorcode;
  71                 }
  72         }
  73
  74         /* check if it's CALL */
  75         if ( sessionType == MM_SESSION_TYPE_CALL )
  76         {
  77                 debug_log("session type is CALL\n");
  78                 sm->event = ASM_EVENT_CALL;
  79                 return MM_ERROR_NONE;
  80         }
  81         else if ( sessionType == MM_SESSION_TYPE_VIDEOCALL )
  82         {
  83                 debug_log("session type is VIDEOCALL\n");
  84                 sm->event = ASM_EVENT_VIDEOCALL;
  85                 return MM_ERROR_NONE;
  86         }
  87
  88         /* interpret session type */
  89         event_type = __mmplayer_asm_get_event_type(sessionType);
  90
  91
  92
  93         /* register audio-session-manager callback */
  94         if( ! ASM_register_sound(pid, &asm_handle, event_type, ASM_STATE_NONE, callback, (void*)param, ASM_RESOURCE_NONE, &errorcode))
  95         {
  96                 debug_critical("ASM_register_sound() failed\n");
  97                 return errorcode;
  98         }
  99
 100         /* now succeed to register our callback. take result */
 101         sm->handle = asm_handle;
 102         sm->state = ASM_STATE_NONE;
 103         sm->event = event_type;
 104
 105         return MM_ERROR_NONE;
 106 }
 107
 108 gint
 109 _mmplayer_asm_deregister(MMPlayerASM* sm)
 110 {
 111         gint event_type = ASM_EVENT_NONE;
 112         gint errorcode = 0;
 113         gint pid = -1;
 114
 115         if ( ! sm )
 116         {
 117                 debug_error("invalid session handle\n");
 118                 return MM_ERROR_PLAYER_NOT_INITIALIZED;
 119         }
 120
 121         /* check if it's running on the media_server */
 122         if ( sm->pid > 0 )
 123         {
 124                 pid = sm->pid;
 125                 debug_log("mm-player is running on different process. Just faking pid to [%d]. :-p\n", pid);
 126         }
 127         else
 128         {
 129                 debug_log("no pid has assigned. using default(current) context\n");
 130         }
 131
 132         /* check if it's CALL */
 133         if(sm->event == ASM_EVENT_CALL || sm->event == ASM_EVENT_VIDEOCALL)
 134         {
 135                 debug_log("session type is VOICE or VIDEO CALL (%d)\n", sm->event);
 136                 return MM_ERROR_NONE;
 137         }
 138         event_type = sm->event;
 139
 140         if( ! ASM_unregister_sound( sm->handle, event_type, &errorcode) )
 141         {
 142                 debug_error("Unregister sound failed 0x%X\n", errorcode);
 143                 return MM_ERROR_POLICY_INTERNAL;
 144         }
 145
 146         return MM_ERROR_NONE;
 147 }
 148
 149 gint _mmplayer_asm_set_state(MMHandleType hplayer, ASM_sound_states_t state)
 150 {
 151         gint event_type = ASM_EVENT_NONE;
 152         gint pid = -1;
 153         ASM_resource_t resource = ASM_RESOURCE_NONE;
 154         mm_player_t *player = (mm_player_t *)hplayer;
 155         MMPlayerASM* sm  = &player->sm;
 156
 157         if ( ! sm )
 158         {
 159                 debug_error("invalid session handle\n");
 160                 return MM_ERROR_PLAYER_NOT_INITIALIZED;
 161         }
 162
 163         /* check if it's running on the media_server */
 164         if ( sm->pid > 0 )
 165         {
 166                 pid = sm->pid;
 167                 debug_log("mm-player is running on different process. Just faking pid to [%d]. :-p\n", pid);
 168         }
 169         else
 170         {
 171                 debug_log("no pid has assigned. using default(current) context\n");
 172         }
 173
 174         /* check if it's CALL */
 175         if(sm->event == ASM_EVENT_CALL || sm->event == ASM_EVENT_VIDEOCALL)
 176         {
 177                 debug_log("session type is VOICE or VIDEO CALL (%d)\n", sm->event);
 178                 return MM_ERROR_NONE;
 179         }
 180
 181
 182         if ( ! sm->by_asm_cb )//|| sm->state == ASM_STATE_PLAYING )
 183         {
 184                 int ret = 0;
 185                 event_type = sm->event;
 186
 187                 /* check if there is video */
 188                 /* NOTE: resource can be set as NONE when it's not occupied or unknown resource is used. */
 189                 if(ASM_STATE_PLAYING == state || ASM_STATE_PAUSE == state)
 190                 {
 191                         if(player->pipeline && player->pipeline->videobin)
 192                                 resource = ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_DECODER;
 193                 }
 194
 195                 if( ! ASM_set_sound_state( sm->handle, event_type, state, resource, &ret) )
 196                 {
 197                         debug_error("Set state to [%d] failed 0x%X\n", state, ret);
 198                         return MM_ERROR_POLICY_BLOCKED;
 199                 }
 200
 201                 sm->state = state;
 202         }
 203         else
 204         {
 205                 sm->by_asm_cb = 0;
 206                 sm->state = state;
 207         }
 208
 209         return MM_ERROR_NONE;
 210 }
 211
 212 static ASM_sound_events_t
 213 __mmplayer_asm_get_event_type(gint type)
 214 {
 215         gint event_type = ASM_EVENT_NONE;
 216
 217         /* interpret session type */
 218                 switch(type)
 219                 {
 220                         case MM_SESSION_TYPE_SHARE:
 221                                 event_type = ASM_EVENT_SHARE_MMPLAYER;
 222                         break;
 223
 224                         case MM_SESSION_TYPE_EXCLUSIVE:
 225                                 event_type = ASM_EVENT_EXCLUSIVE_MMPLAYER;
 226                         break;
 227
 228                         case MM_SESSION_TYPE_NOTIFY:
 229                                 event_type = ASM_EVENT_NOTIFY;
 230                         break;
 231
 232                         case MM_SESSION_TYPE_ALARM:
 233                                 event_type = ASM_EVENT_ALARM;
 234                         break;
 235
 236                         case MM_SOUND_VOLUME_TYPE_EMERGENCY:
 237                                 event_type = ASM_EVENT_EMERGENCY;
 238                         break;
 239
 240                         default:
 241                                 debug_critical("unexpected case!\n");
 242                                 event_type = ASM_EVENT_SHARE_MMPLAYER;
 243                         break;
 244                 }
 245
 246                 return event_type;
 247 }