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
 133                         MMRADIO_LOG_DEBUG("register focus watch callback for the value is 0, sub_cb id %d\n", sound_focus->subscribe_id);
 134                         /* register watch callback */
 135                         ret = mm_sound_set_focus_watch_callback_for_session(pid,
 136                                         FOCUS_FOR_BOTH, watch_cb, (void *)param, &sound_focus->watch_id);
 137                         if (ret != MM_ERROR_NONE) {
 138                                 MMRADIO_LOG_ERROR("mm_sound_set_focus_watch_callback is failed\n");
 139                                 return MM_ERROR_POLICY_BLOCKED;
 140                         }
 141                         MMRADIO_LOG_DEBUG("(%p) set focus watch callback = %d", param, sound_focus->watch_id);
 142
 143                         /* register device connected callback */
 144                         ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
 145                                         (mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void *)param, &sound_focus->device_subs_id);
 146                         if (ret != MM_ERROR_NONE) {
 147                                 MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 148                                 return MM_ERROR_POLICY_BLOCKED;
 149                         }
 150                         MMRADIO_LOG_ERROR("register device connected callback for the value is 0, sub_cb id %d\n", sound_focus->device_subs_id);
 151                 }
 152                 ret = MM_ERROR_NONE;
 153         } else if (ret == MM_ERROR_NONE) {
 154                 MMRADIO_LOG_WARNING("Read Session Information success. session_type : %d flags: %d \n", session_type, session_flags);
 155                 sound_focus->session_type = session_type;
 156                 sound_focus->snd_session_flags = session_flags;
 157                 if (sound_focus->session_type == MM_SESSION_TYPE_MEDIA) {
 158                         if (sound_focus->snd_session_flags & MM_SESSION_OPTION_PAUSE_OTHERS) {
 159                                 /* register focus session */
 160                                 sound_focus->pid = pid;
 161                                 MMRADIO_LOG_DEBUG("sound register focus pid[%d]", pid);
 162                                 ret = mm_sound_focus_get_id(&handle);
 163                                 if (ret != MM_ERROR_NONE) {
 164                                         MMRADIO_LOG_ERROR("Failed to get sound focus id");
 165                                         return MM_ERROR_POLICY_BLOCKED;
 166                                 }
 167                                 sound_focus->handle = handle;
 168
 169                                 ret = mm_sound_register_focus_for_session(handle, pid, "radio", focus_cb, param);
 170                                 if (ret != MM_ERROR_NONE) {
 171                                         MMRADIO_LOG_DEBUG("mm_sound_register_focus_for_session is failed\n");
 172                                         return MM_ERROR_POLICY_BLOCKED;
 173                                 }
 174                                 MMRADIO_LOG_DEBUG("(%p) register focus for session %d", param, pid);
 175                                 /* register device_connected_cb */
 176                                 ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
 177                                         (mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void *)param, &sound_focus->device_subs_id);
 178                                 if (ret != MM_ERROR_NONE) {
 179                                         MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 180                                         return MM_ERROR_POLICY_BLOCKED;
 181                                 }
 182                                 MMRADIO_LOG_DEBUG("(%p) add device connected callback = %d", param, sound_focus->device_subs_id);
 183
 184                         } else if (sound_focus->snd_session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
 185                                 /* register device_connected_cb */
 186                                 ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
 187                                         (mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void*)param, &sound_focus->device_subs_id);
 188                                 if (ret != MM_ERROR_NONE) {
 189                                         MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 190                                         return MM_ERROR_POLICY_BLOCKED;
 191                                 }
 192                                 MMRADIO_LOG_DEBUG("add device connected callback = %d", sound_focus->device_subs_id);
 193                                 MMRADIO_LOG_WARNING("settion flags isn't OPTION_PAUSE_OTHERS and UNINTERRUPTIBLE. skip it..");
 194                         } else {
 195                                 /* register watch callback */
 196                                 ret = mm_sound_set_focus_watch_callback_for_session(pid,
 197                                                 FOCUS_FOR_BOTH, watch_cb, (void*)param, &sound_focus->watch_id);
 198                                 if (ret != MM_ERROR_NONE) {
 199                                         MMRADIO_LOG_ERROR("mm_sound_set_focus_watch_callback is failed\n");
 200                                         return MM_ERROR_POLICY_BLOCKED;
 201                                 }
 202                                 MMRADIO_LOG_DEBUG("set focus watch callback = %d", sound_focus->watch_id);
 203
 204                                 /* register device connected callback */
 205                                 ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_TYPE_EXTERNAL_FLAG,
 206                                                 (mm_sound_device_connected_cb)_mmradio_device_connected_cb, (void*)param, &sound_focus->device_subs_id);
 207                                 if (ret != MM_ERROR_NONE) {
 208                                         MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 209                                         return MM_ERROR_POLICY_BLOCKED;
 210                                 }
 211                                 MMRADIO_LOG_DEBUG("(%p) add device connected callback = %d", param, sound_focus->device_subs_id);
 212                         }
 213                 } else if (sound_focus->session_type == MM_SESSION_TYPE_REPLACED_BY_STREAM) {
 214                         /* didn't register device connected cb */
 215                         MMRADIO_LOG_WARNING("this process is using stream info. skip it..");
 216                 } else {
 217                         MMRADIO_LOG_WARNING("seesion type is not MEDIA (%d)", sound_focus->session_type);
 218                         return MM_ERROR_RADIO_INTERNAL;
 219                 }
 220                 ret = MM_ERROR_NONE;
 221         } else {
 222                 MMRADIO_LOG_WARNING("Read Session Information failed. skip sound focus register function. errorcode %x \n", ret);
 223         }
 224
 225         MMRADIO_LOG_FLEAVE();
 226
 227         return MM_ERROR_NONE;
 228 }
 229
 230 int mmradio_sound_focus_deregister(mm_radio_sound_focus *sound_focus)
 231 {
 232
 233         int ret = MM_ERROR_NONE;
 234
 235         MMRADIO_LOG_FENTER();
 236
 237         if (!sound_focus) {
 238                 MMRADIO_LOG_ERROR("invalid session handle\n");
 239                 return MM_ERROR_RADIO_NOT_INITIALIZED;
 240         }
 241
 242         if (sound_focus->watch_id > 0) {
 243                 MMRADIO_LOG_DEBUG("unset the focus watch cb %d", sound_focus->watch_id);
 244
 245                 ret = mm_sound_unset_focus_watch_callback(sound_focus->watch_id);
 246                 sound_focus->watch_id = 0;
 247                 if (ret != MM_ERROR_NONE)
 248                         MMRADIO_LOG_ERROR("failed to mm_sound_unset_focus_watch_callback() ret = %d", ret);
 249         }
 250         /* unregister focus callback */
 251         if (sound_focus->focus_id > 0) {
 252                 ret = mm_sound_unregister_focus(sound_focus->focus_id);
 253                 sound_focus->focus_id = 0;
 254                 if (ret != MM_ERROR_NONE)
 255                         MMRADIO_LOG_ERROR("failed to mm_sound_unregister_focus() ret = %d", ret);
 256         }
 257         /* unregister device connected callback */
 258         if (sound_focus->device_subs_id > 0) {
 259                 MMRADIO_LOG_DEBUG("unset the device connected cb %d", sound_focus->device_subs_id);
 260                 ret = mm_sound_remove_device_connected_callback(sound_focus->device_subs_id);
 261                 sound_focus->device_subs_id = 0;
 262                 if (ret != MM_ERROR_NONE)
 263                         MMRADIO_LOG_ERROR("failed to mm_sound_remove_device_connected_callback() ret = %d", ret);
 264         }
 265
 266         MMRADIO_LOG_FLEAVE();
 267
 268         return MM_ERROR_NONE;
 269 }
 270
 271 int mmradio_acquire_sound_focus(mm_radio_sound_focus *sound_focus)
 272 {
 273         int ret = MM_ERROR_NONE;
 274         mm_sound_focus_type_e focus_type = FOCUS_NONE;
 275         MMRADIO_LOG_FENTER();
 276
 277         MMRADIO_LOG_ERROR("mmradio_acquire_sound_focus sound_focus->cur_focus_type : %d\n", sound_focus->cur_focus_type);
 278
 279         focus_type = FOCUS_FOR_BOTH & ~(sound_focus->cur_focus_type);
 280         if (focus_type != FOCUS_NONE) {
 281                 ret = mm_sound_acquire_focus(sound_focus->handle, focus_type, NULL);
 282                 if (ret != MM_ERROR_NONE) {
 283                         MMRADIO_LOG_ERROR("mm_sound_acquire_focus is failed\n");
 284                         return MM_ERROR_POLICY_BLOCKED;
 285                 }
 286                 sound_focus->cur_focus_type = FOCUS_FOR_BOTH;
 287         }
 288
 289         MMRADIO_LOG_FLEAVE();
 290         return ret;
 291 }
 292
 293 int mmradio_release_sound_focus(mm_radio_sound_focus *sound_focus)
 294 {
 295         int ret = MM_ERROR_NONE;
 296         MMRADIO_LOG_FENTER();
 297
 298         MMRADIO_LOG_ERROR("mmradio_release_sound_focus sound_focus->cur_focus_type : %d\n", sound_focus->cur_focus_type);
 299         if (sound_focus->cur_focus_type != FOCUS_NONE) {
 300                 ret = mm_sound_release_focus(sound_focus->handle, sound_focus->cur_focus_type, NULL);
 301                 if (ret != MM_ERROR_NONE) {
 302                         MMRADIO_LOG_ERROR("mm_sound_release_focus is failed\n");
 303                         return MM_ERROR_POLICY_BLOCKED;
 304                 }
 305                 sound_focus->cur_focus_type = FOCUS_NONE;
 306         }
 307
 308         MMRADIO_LOG_FLEAVE();
 309         return ret;
 310 }
 311
 312 #define AUDIO_FOCUS_REASON_MAX  128
 313
 314 void mmradio_get_sound_focus_reason(mm_sound_focus_state_e focus_state, const char *reason_for_change, enum MMMessageInterruptedCode *event_source, int *postMsg)
 315 {
 316         MMRADIO_LOG_FENTER();
 317         MMRADIO_LOG_ERROR("mmradio_get_sound_focus_reason focus_state : %d reason_for_change :%s\n", focus_state, reason_for_change);
 318
 319         if (0 == strncmp(reason_for_change, "call-voice", AUDIO_FOCUS_REASON_MAX)
 320                 || (0 == strncmp(reason_for_change, "voip", AUDIO_FOCUS_REASON_MAX))
 321                 || (0 == strncmp(reason_for_change, "ringtone-voip", AUDIO_FOCUS_REASON_MAX))
 322                 || (0 == strncmp(reason_for_change, "ringtone-call", AUDIO_FOCUS_REASON_MAX))
 323                 ) {
 324                 if (focus_state == FOCUS_IS_RELEASED)
 325                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_CALL_START;
 326                 else if (focus_state == FOCUS_IS_ACQUIRED)
 327                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_CALL_END;
 328                 *postMsg = true;
 329         } else if (0 == strncmp(reason_for_change, "alarm", AUDIO_FOCUS_REASON_MAX)) {
 330                 if (focus_state == FOCUS_IS_RELEASED)
 331                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_ALARM_START;
 332                 else if (focus_state == FOCUS_IS_ACQUIRED)
 333                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_ALARM_END;
 334                 *postMsg = true;
 335         } else if (0 == strncmp(reason_for_change, "notification", AUDIO_FOCUS_REASON_MAX)) {
 336                 if (focus_state == FOCUS_IS_RELEASED)
 337                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_START;
 338                 else if (focus_state == FOCUS_IS_ACQUIRED)
 339                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_END;
 340                 *postMsg = true;
 341         } else if (0 == strncmp(reason_for_change, "emergency", AUDIO_FOCUS_REASON_MAX)) {
 342                 if (focus_state == FOCUS_IS_RELEASED)
 343                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START;
 344                 else if (focus_state == FOCUS_IS_ACQUIRED)
 345                         *event_source = MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END;
 346                 *postMsg = false;
 347         } else if (0 == strncmp(reason_for_change, "media", AUDIO_FOCUS_REASON_MAX)) {
 348                 *event_source = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
 349                 *postMsg = false;
 350         } else {
 351                 *event_source = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
 352                 *postMsg = false;
 353         }
 354         MMRADIO_LOG_FLEAVE();
 355 }