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>,
   7  * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <glib.h>
  24 #include <mm_debug.h>
  25 #include "mm_player_priv.h"
  26 #include "mm_player_asm.h"
  27
  28 static ASM_sound_events_t __mmplayer_asm_get_event_type(gint type);
  29
  30 gint 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 mmplayer_asm_deregister(MMPlayerASM* sm)
 109 {
 110         gint event_type = ASM_EVENT_NONE;
 111         gint errorcode = 0;
 112         gint pid = -1;
 113
 114         if ( ! sm )
 115         {
 116                 debug_error("invalid session handle\n");
 117                 return MM_ERROR_PLAYER_NOT_INITIALIZED;
 118         }
 119
 120         /* check if it's running on the media_server */
 121         if ( sm->pid > 0 )
 122         {
 123                 pid = sm->pid;
 124                 debug_log("mm-player is running on different process. Just faking pid to [%d]. :-p\n", pid);
 125         }
 126         else
 127         {
 128                 debug_log("no pid has assigned. using default(current) context\n");
 129         }
 130         /* check if it's CALL */
 131         if(sm->event == ASM_EVENT_CALL || sm->event == ASM_EVENT_VIDEOCALL)
 132         {
 133                 debug_log("session type is VOICE or VIDEO CALL (%d)\n", sm->event);
 134                 return MM_ERROR_NONE;
 135         }
 136         event_type = sm->event;
 137
 138         if( ! ASM_unregister_sound( sm->handle, event_type, &errorcode) )
 139         {
 140                 debug_error("Unregister sound failed 0x%X\n", errorcode);
 141                 return MM_ERROR_POLICY_INTERNAL;
 142         }
 143
 144         return MM_ERROR_NONE;
 145 }
 146
 147 gint mmplayer_asm_set_state(MMHandleType hplayer, ASM_sound_states_t state)
 148 {
 149         gint event_type = ASM_EVENT_NONE;
 150         gint pid = -1;
 151         ASM_resource_t resource = ASM_RESOURCE_NONE;
 152         mm_player_t *player = (mm_player_t *)hplayer;
 153         MMPlayerASM* sm  = &player->sm;
 154
 155         if ( ! sm )
 156         {
 157                 debug_error("invalid session handle\n");
 158                 return MM_ERROR_PLAYER_NOT_INITIALIZED;
 159         }
 160
 161         /* check if it's running on the media_server */
 162         if ( sm->pid > 0 )
 163         {
 164                 pid = sm->pid;
 165                 debug_log("mm-player is running on different process. Just faking pid to [%d]. :-p\n", pid);
 166         }
 167         else
 168         {
 169                 debug_log("no pid has assigned. using default(current) context\n");
 170         }
 171         /* check if it's CALL */
 172         if(sm->event == ASM_EVENT_CALL || sm->event == ASM_EVENT_VIDEOCALL)
 173         {
 174                 debug_log("session type is VOICE or VIDEO CALL (%d)\n", sm->event);
 175                 return MM_ERROR_NONE;
 176         }
 177
 178         if ( ! sm->by_asm_cb )
 179         {
 180                 int ret = 0;
 181
 182                 event_type = sm->event;
 183                 /* check if there is video */
 184                 /* NOTE: resource can be set as NONE when it's not occupied or unknown resource is used. */
 185                 if(ASM_STATE_PLAYING == state || ASM_STATE_PAUSE == state)
 186                 {
 187                         if(player->pipeline && player->pipeline->videobin)
 188                         resource = ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_DECODER;
 189                 }
 190
 191                 if( ! ASM_set_sound_state( sm->handle, event_type, state, resource, &ret) )
 192                 {
 193                         debug_error("Set state to [%d] failed 0x%X\n", state, ret);
 194                         return MM_ERROR_POLICY_BLOCKED;
 195                 }
 196
 197                 sm->state = state;
 198         }
 199         else
 200         {
 201                 sm->by_asm_cb = 0;
 202                 sm->state = state;
 203         }
 204
 205         return MM_ERROR_NONE;
 206 }
 207
 208
 209 ASM_sound_events_t __mmplayer_asm_get_event_type(gint type)
 210 {
 211         gint event_type = ASM_EVENT_NONE;
 212
 213         /* interpret session type */
 214                 switch(type)
 215                 {
 216                         case MM_SESSION_TYPE_SHARE:
 217                                 event_type = ASM_EVENT_SHARE_MMPLAYER;
 218                         break;
 219
 220                         case MM_SESSION_TYPE_EXCLUSIVE:
 221                                 event_type = ASM_EVENT_EXCLUSIVE_MMPLAYER;
 222                         break;
 223
 224                         case MM_SESSION_TYPE_NOTIFY:
 225                                 event_type = ASM_EVENT_NOTIFY;
 226                         break;
 227
 228                         case MM_SESSION_TYPE_ALARM:
 229                                 event_type = ASM_EVENT_ALARM;
 230                         break;
 231                         default:
 232                                 debug_critical("unexpected case!\n");
 233                                 g_assert(0);
 234                 }
 235
 236                 return event_type;
 237 }