src/mm_radio_sound_focus.c

   1 /*
   2  * mm_radio_sound_focus.c
   3  *
   4  * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <assert.h>
  21 #include <unistd.h>
  22 #include <mm_debug.h>
  23 #include <mm_sound.h>
  24 #include <mm_sound_focus.h>
  25 #include <mm_sound_device.h>
  26 #include "mm_radio_utils.h"
  27 #include "mm_radio_priv_hal.h"
  28 #include "mm_radio_sound_focus.h"
  29
  30 static void _mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connected, void *user_data)
  31 {
  32         mm_radio_t *radio = (mm_radio_t *)user_data;
  33         int result = MM_ERROR_NONE;
  34         mm_sound_device_type_e type;
  35
  36         MMRADIO_LOG_FENTER();
  37         MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
  38
  39         if (mm_sound_get_device_type(device, &type) != MM_ERROR_NONE) {
  40                 MMRADIO_LOG_ERROR("getting device type failed");
  41         } else {
  42                 switch (type) {
  43                 case MM_SOUND_DEVICE_TYPE_AUDIOJACK:
  44                 case MM_SOUND_DEVICE_TYPE_BLUETOOTH:
  45                 case MM_SOUND_DEVICE_TYPE_HDMI:
  46                 case MM_SOUND_DEVICE_TYPE_MIRRORING:
  47                 case MM_SOUND_DEVICE_TYPE_USB_AUDIO:
  48                         if (!is_connected) {
  49                                 MMRADIO_LOG_ERROR("sound device unplugged");
  50                                 radio->sound_focus.by_focus_cb = MMRADIO_FOCUS_CB_POSTMSG;
  51                                 radio->sound_focus.event_src = MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG;
  52
  53                                 result = _mmradio_stop(radio);
  54                                 if (result != MM_ERROR_NONE)
  55                                         MMRADIO_LOG_ERROR("failed to stop radio\n");
  56                         }
  57                         break;
  58                 default:
  59                         break;
  60                 }
  61         }
  62         MMRADIO_LOG_FLEAVE();
  63 }
  64
  65 void _mmradio_sound_signal_callback(mm_sound_signal_name_t signal, int value, void *user_data)
  66 {
  67         mm_radio_sound_focus *sound_focus = (mm_radio_sound_focus *)user_data;
  68         int ret = MM_ERROR_NONE;
  69
  70         MMRADIO_LOG_DEBUG("sound signal callback %d / %d", signal, value);
  71
  72         if (signal == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) {
  73                 if (value == 1) {
  74                         /* unregister watch callback */
  75                         if (sound_focus->watch_id > 0) {
  76                                 MMRADIO_LOG_DEBUG("unset the focus watch cb %d", sound_focus->watch_id);
  77
  78                                 ret = mm_sound_unset_focus_watch_callback(sound_focus->watch_id);
  79                                 sound_focus->watch_id = 0;
  80                                 if (ret != MM_ERROR_NONE)
  81                                         MMRADIO_LOG_ERROR("failed to mm_sound_unset_focus_watch_callback()");
  82                         }
  83                         /* unregister focus callback */
  84                         if (sound_focus->focus_id > 0) {
  85                                 ret = mm_sound_unregister_focus(sound_focus->focus_id);
  86                                 sound_focus->focus_id = 0;
  87                                 if (ret != MM_ERROR_NONE)
  88                                         MMRADIO_LOG_ERROR("failed to mm_sound_unregister_focus() %d", sound_focus->focus_id);
  89                         }
  90                         /* unregister device connected callback */
  91                         if (sound_focus->device_subs_id > 0) {
  92                                 MMRADIO_LOG_DEBUG("unset the device connected cb %d", sound_focus->device_subs_id);
  93                                 ret = mm_sound_remove_device_connected_callback(sound_focus->device_subs_id);
  94                                 sound_focus->device_subs_id = 0;
  95                                 if (ret != MM_ERROR_NONE)
  96                                         MMRADIO_LOG_ERROR("failed to mm_sound_remove_device_connected_callback()");
  97                         }
  98                 }
  99         }
 100 }
 101
 102 int mmradio_sound_focus_register(mm_radio_sound_focus *sound_focus,
 103         mm_sound_focus_changed_cb focus_cb, mm_sound_focus_changed_watch_cb watch_cb, void *param)
 104 {
 105         /* read mm-session information */
 106         int session_type = MM_SESSION_TYPE_MEDIA;
 107         int session_flags = 0;
 108         int ret = MM_ERROR_NONE;
 109         int pid = getpid();
 110         int handle = 0;
 111
 112         MMRADIO_LOG_FENTER();
 113
 114         if (!sound_focus) {
 115                 MMRADIO_LOG_ERROR("invalid session handle\n");
 116                 return MM_ERROR_RADIO_NOT_INITIALIZED;
 117         }
 118         sound_focus->cur_focus_type = FOCUS_NONE;
 119
 120         /* read session information */
 121         ret = _mm_session_util_read_information(pid, &session_type, &session_flags);
 122         MMRADIO_LOG_DEBUG("Read Session type ret:0x%X", ret);
 123         if (ret == MM_ERROR_INVALID_HANDLE) {
 124                 MMRADIO_LOG_WARNING("subscribe_id=%d\n", sound_focus->subscribe_id);
 125                 if (sound_focus->subscribe_id == 0) {
 126                         ret = mm_sound_subscribe_signal_for_daemon(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, pid, &sound_focus->subscribe_id,
 127                                                                         (mm_sound_signal_callback)_mmradio_sound_signal_callback, (void*)sound_focus);
 128                         if (ret != MM_ERROR_NONE) {
 129                                 MMRADIO_LOG_ERROR("mm_sound_subscribe_signal is failed\n");
 130                                 return MM_ERROR_POLICY_BLOCKED;
 131                         }
 132                         MMRADIO_LOG_DEBUG("register focus watch callback for the value is 0, sub_cb id %d\n", sound_focus->subscribe_id);
 133                         /* register watch callback */
 134                         ret = mm_sound_set_focus_watch_callback_for_session(pid,
 135                                         FOCUS_FOR_BOTH, watch_cb, (void *)param, &sound_focus->watch_id);
 136                         if (ret != MM_ERROR_NONE) {
 137                                 MMRADIO_LOG_ERROR("mm_sound_set_focus_watch_callback is failed\n");
 138                                 return MM_ERROR_POLICY_BLOCKED;
 139                         }
 140                         MMRADIO_LOG_DEBUG("(%p) set focus watch callback = %d", param, sound_focus->watch_id);
 141
 142                         /* register device connected callback */
 143                         ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
 144                                         (mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void *)param, &sound_focus->device_subs_id);
 145                         if (ret != MM_ERROR_NONE) {
 146                                 MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 147                                 return MM_ERROR_POLICY_BLOCKED;
 148                         }
 149                         MMRADIO_LOG_ERROR("register device connected callback for the value is 0, sub_cb id %d\n", sound_focus->device_subs_id);
 150                 }
 151                 ret = MM_ERROR_NONE;
 152         } else if (ret == MM_ERROR_NONE) {
 153                 MMRADIO_LOG_WARNING("Read Session Information success. session_type : %d flags: %d \n", session_type, session_flags);
 154                 sound_focus->session_type = session_type;
 155                 sound_focus->snd_session_flags = session_flags;
 156                 if (sound_focus->session_type == MM_SESSION_TYPE_MEDIA) {
 157                         if (sound_focus->snd_session_flags & MM_SESSION_OPTION_PAUSE_OTHERS) {
 158                                 /* register focus session */
 159                                 sound_focus->pid = pid;
 160                                 MMRADIO_LOG_DEBUG("sound register focus pid[%d]", pid);
 161                                 ret = mm_sound_focus_get_id(&handle);
 162                                 if (ret != MM_ERROR_NONE) {
 163                                         MMRADIO_LOG_ERROR("Failed to get sound focus id");
 164                                         return MM_ERROR_POLICY_BLOCKED;
 165                                 }
 166                                 sound_focus->handle = handle;
 167
 168                                 ret = mm_sound_register_focus_for_session(handle, pid, "radio", focus_cb, param);
 169                                 if (ret != MM_ERROR_NONE) {
 170                                         MMRADIO_LOG_DEBUG("mm_sound_register_focus_for_session is failed\n");
 171                                         return MM_ERROR_POLICY_BLOCKED;
 172                                 }
 173                                 MMRADIO_LOG_DEBUG("(%p) register focus for session %d", param, pid);
 174                                 /* register device_connected_cb */
 175                                 ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
 176                                         (mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void *)param, &sound_focus->device_subs_id);
 177                                 if (ret != MM_ERROR_NONE) {
 178                                         MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 179                                         return MM_ERROR_POLICY_BLOCKED;
 180                                 }
 181                                 MMRADIO_LOG_DEBUG("(%p) add device connected callback = %d", param, sound_focus->device_subs_id);
 182
 183                         } else if (sound_focus->snd_session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
 184                                 /* register device_connected_cb */
 185                                 ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
 186                                         (mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void*)param, &sound_focus->device_subs_id);
 187                                 if (ret != MM_ERROR_NONE) {
 188                                         MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 189                                         return MM_ERROR_POLICY_BLOCKED;
 190                                 }
 191                                 MMRADIO_LOG_DEBUG("add device connected callback = %d", sound_focus->device_subs_id);
 192                                 MMRADIO_LOG_WARNING("settion flags isn't OPTION_PAUSE_OTHERS and UNINTERRUPTIBLE. skip it..");
 193                         } else {
 194                                 /* register watch callback */
 195                                 ret = mm_sound_set_focus_watch_callback_for_session(pid,
 196                                                 FOCUS_FOR_BOTH, watch_cb, (void*)param, &sound_focus->watch_id);
 197                                 if (ret != MM_ERROR_NONE) {
 198                                         MMRADIO_LOG_ERROR("mm_sound_set_focus_watch_callback is failed\n");
 199                                         return MM_ERROR_POLICY_BLOCKED;
 200                                 }
 201                                 MMRADIO_LOG_DEBUG("set focus watch callback = %d", sound_focus->watch_id);
 202
 203                                 /* register device connected callback */
 204                                 ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
 205                                                 (mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void*)param, &sound_focus->device_subs_id);
 206                                 if (ret != MM_ERROR_NONE) {
 207                                         MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 208                                         return MM_ERROR_POLICY_BLOCKED;
 209                                 }
 210                                 MMRADIO_LOG_DEBUG("(%p) add device connected callback = %d", param, sound_focus->device_subs_id);
 211                         }
 212                 } else if (sound_focus->session_type == MM_SESSION_TYPE_REPLACED_BY_STREAM) {
 213                         /* didn't register device connected cb */
 214                         MMRADIO_LOG_WARNING("this process is using stream info. skip it..");
 215                 } else {
 216                         MMRADIO_LOG_WARNING("seesion type is not MEDIA (%d)", sound_focus->session_type);
 217                         return MM_ERROR_RADIO_INTERNAL;
 218                 }
 219                 ret = MM_ERROR_NONE;
 220         } else {
 221                 MMRADIO_LOG_WARNING("Read Session Information failed. skip sound focus register function. errorcode %x \n", ret);
 222         }
 223
 224         MMRADIO_LOG_FLEAVE();
 225
 226         return MM_ERROR_NONE;
 227 }
 228
 229 int mmradio_sound_focus_deregister(mm_radio_sound_focus *sound_focus)
 230 {
 231
 232         int ret = MM_ERROR_NONE;
 233
 234         MMRADIO_LOG_FENTER();
 235
 236         if (!sound_focus) {
 237                 MMRADIO_LOG_ERROR("invalid session handle\n");
 238                 return MM_ERROR_RADIO_NOT_INITIALIZED;
 239         }
 240
 241         if (sound_focus->watch_id > 0) {
 242                 MMRADIO_LOG_DEBUG("unset the focus watch cb %d", sound_focus->watch_id);
 243
 244                 ret = mm_sound_unset_focus_watch_callback(sound_focus->watch_id);
 245                 sound_focus->watch_id = 0;
 246                 if (ret != MM_ERROR_NONE)
 247                         MMRADIO_LOG_ERROR("failed to mm_sound_unset_focus_watch_callback() ret = %d", ret);
 248         }
 249         /* unregister focus callback */
 250         if (sound_focus->focus_id > 0) {
 251                 ret = mm_sound_unregister_focus(sound_focus->focus_id);
 252                 sound_focus->focus_id = 0;
 253                 if (ret != MM_ERROR_NONE)
 254                         MMRADIO_LOG_ERROR("failed to mm_sound_unregister_focus() ret = %d", ret);
 255         }
 256         /* unregister device connected callback */
 257         if (sound_focus->device_subs_id > 0) {
 258                 MMRADIO_LOG_DEBUG("unset the device connected cb %d", sound_focus->device_subs_id);
 259                 ret = mm_sound_remove_device_connected_callback(sound_focus->device_subs_id);
 260                 sound_focus->device_subs_id = 0;
 261                 if (ret != MM_ERROR_NONE)
 262                         MMRADIO_LOG_ERROR("failed to mm_sound_remove_device_connected_callback() ret = %d", ret);
 263         }
 264
 265         MMRADIO_LOG_FLEAVE();
 266
 267         return MM_ERROR_NONE;
 268 }
 269
 270 int mmradio_acquire_sound_focus(mm_radio_sound_focus *sound_focus)
 271 {
 272         int ret = MM_ERROR_NONE;
 273         mm_sound_focus_type_e focus_type = FOCUS_NONE;
 274         MMRADIO_LOG_FENTER();
 275
 276         MMRADIO_LOG_ERROR("mmradio_acquire_sound_focus sound_focus->cur_focus_type : %d\n", sound_focus->cur_focus_type);
 277
 278         focus_type = FOCUS_FOR_BOTH & ~(sound_focus->cur_focus_type);
 279         if (focus_type != FOCUS_NONE) {
 280                 ret = mm_sound_acquire_focus(sound_focus->handle, focus_type, NULL);
 281                 if (ret != MM_ERROR_NONE) {
 282                         MMRADIO_LOG_ERROR("mm_sound_acquire_focus is failed\n");
 283                         return MM_ERROR_POLICY_BLOCKED;
 284                 }
 285                 sound_focus->cur_focus_type = FOCUS_FOR_BOTH;
 286         }
 287
 288         MMRADIO_LOG_FLEAVE();
 289         return ret;
 290 }
 291
 292 int mmradio_release_sound_focus(mm_radio_sound_focus *sound_focus)
 293 {
 294         int ret = MM_ERROR_NONE;
 295         MMRADIO_LOG_FENTER();
 296
 297         MMRADIO_LOG_ERROR("mmradio_release_sound_focus sound_focus->cur_focus_type : %d\n", sound_focus->cur_focus_type);
 298         if (sound_focus->cur_focus_type != FOCUS_NONE) {
 299                 ret = mm_sound_release_focus(sound_focus->handle, sound_focus->cur_focus_type, NULL);
 300                 if (ret != MM_ERROR_NONE) {
 301                         MMRADIO_LOG_ERROR("mm_sound_release_focus is failed\n");
 302                         return MM_ERROR_POLICY_BLOCKED;
 303                 }
 304                 sound_focus->cur_focus_type = FOCUS_NONE;
 305         }
 306
 307         MMRADIO_LOG_FLEAVE();
 308         return ret;
 309 }
 310
 311 #define AUDIO_FOCUS_REASON_MAX  128
 312
 313 void mmradio_get_sound_focus_reason(mm_sound_focus_state_e focus_state, const char *reason_for_change, enum MMMessageInterruptedCode *event_source, int *postMsg)
 314 {
 315         MMRADIO_LOG_FENTER();
 316         MMRADIO_LOG_ERROR("mmradio_get_sound_focus_reason focus_state : %d reason_for_change :%s\n", focus_state, reason_for_change);
 317
 318         if (0 == strncmp(reason_for_change, "call-voice", AUDIO_FOCUS_REASON_MAX)
 319                 || (0 == strncmp(reason_for_change, "voip", AUDIO_FOCUS_REASON_MAX))
 320                 || (0 == strncmp(reason_for_change, "ringtone-voip", AUDIO_FOCUS_REASON_MAX))
 321                 || (0 == strncmp(reason_for_change, "ringtone-call", AUDIO_FOCUS_REASON_MAX))
 322                 ) {
 323                 if (focus_state == FOCUS_IS_RELEASED)
 324                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_CALL_START;
 325                 else if (focus_state == FOCUS_IS_ACQUIRED)
 326                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_CALL_END;
 327                 *postMsg = true;
 328         } else if (0 == strncmp(reason_for_change, "alarm", AUDIO_FOCUS_REASON_MAX)) {
 329                 if (focus_state == FOCUS_IS_RELEASED)
 330                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_ALARM_START;
 331                 else if (focus_state == FOCUS_IS_ACQUIRED)
 332                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_ALARM_END;
 333                 *postMsg = true;
 334         } else if (0 == strncmp(reason_for_change, "notification", AUDIO_FOCUS_REASON_MAX)) {
 335                 if (focus_state == FOCUS_IS_RELEASED)
 336                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_START;
 337                 else if (focus_state == FOCUS_IS_ACQUIRED)
 338                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_END;
 339                 *postMsg = true;
 340         } else if (0 == strncmp(reason_for_change, "emergency", AUDIO_FOCUS_REASON_MAX)) {
 341                 if (focus_state == FOCUS_IS_RELEASED)
 342                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START;
 343                 else if (focus_state == FOCUS_IS_ACQUIRED)
 344                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END;
 345                 *postMsg = false;
 346         } else if (0 == strncmp(reason_for_change, "media", AUDIO_FOCUS_REASON_MAX)) {
 347                 *event_source = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
 348                 *postMsg = false;
 349         } else {
 350                 *event_source = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
 351                 *postMsg = false;
 352         }
 353         MMRADIO_LOG_FLEAVE();
 354 }