2 * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
20 #include "CAudioIODef.h"
24 using namespace tizen_media_audio;
28 * class CAudioSessionHandler
30 int CAudioSessionHandler::__sCaptureRef = 0;
32 int CAudioSessionHandler::__pcmCaptureCountInc() {
35 actual = __sCaptureRef;
36 } while (!__sync_bool_compare_and_swap(&__sCaptureRef, actual, actual + 1));
37 AUDIO_IO_LOGD("CaptureRefCount+1 > [%d]", __sCaptureRef);
41 int CAudioSessionHandler::__pcmCaptureCountDec() {
44 actual = __sCaptureRef;
45 } while (!__sync_bool_compare_and_swap(&__sCaptureRef, actual, actual - 1));
46 AUDIO_IO_LOGD("CaptureRefCount-1 > [%d]", __sCaptureRef);
47 if (__sCaptureRef < 0) {
48 AUDIO_IO_LOGE("A CaptureRef[%d] is not valid! Something is wrong!", __sCaptureRef);
54 int CAudioSessionHandler::__pcmCaptureCountGet() {
55 AUDIO_IO_LOGD("CaptureRefCount > [%d]", __sCaptureRef);
59 int CAudioSessionHandler::__sFocusRef = 0;
61 int CAudioSessionHandler::__focusIdCountInc() {
65 } while (!__sync_bool_compare_and_swap(&__sFocusRef, actual, actual + 1));
66 AUDIO_IO_LOGD("FocusRefCount+1 > [%d]", __sFocusRef);
70 int CAudioSessionHandler::__focusIdCountDec() {
74 } while (!__sync_bool_compare_and_swap(&__sFocusRef, actual, actual - 1));
75 AUDIO_IO_LOGD("FocusRefCount-1 > [%d]", __sFocusRef);
79 int CAudioSessionHandler::__focusIdCountGet() {
80 /* AUDIO_IO_LOGD("FocusRefCount > [%d]", __sFocusRef); */
84 void CAudioSessionHandler::__lockFocusIdMutex() {
85 if (pthread_mutex_lock(&__mFocusIdMutex) != 0)
86 THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock() - FocusId Mutex");
87 #ifdef _AUDIO_IO_DEBUG_TIMING_
88 AUDIO_IO_LOGD(COLOR_RED "LOCK - FocusId Mutex" COLOR_END);
92 void CAudioSessionHandler::__unlockFocusIdMutex() {
93 if (pthread_mutex_unlock(&__mFocusIdMutex) != 0)
94 THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_unlock() - FocusId Mutex");
95 #ifdef _AUDIO_IO_DEBUG_TIMING_
96 AUDIO_IO_LOGD(COLOR_GREEN "UNLOCK - FocusId Mutex" COLOR_END);
100 void CAudioSessionHandler::__lockFocusCBMutex() {
101 if (pthread_mutex_lock(&__mFocusCBMutex) != 0)
102 THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock() - FocusCB Mutex");
103 #ifdef _AUDIO_IO_DEBUG_TIMING_
104 AUDIO_IO_LOGD(COLOR_RED "LOCK - FocusCB Mutex" COLOR_END);
108 void CAudioSessionHandler::__unlockFocusCBMutex() {
109 if (pthread_mutex_unlock(&__mFocusCBMutex) != 0)
110 THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_unlock() - FocusCB Mutex");
111 #ifdef _AUDIO_IO_DEBUG_TIMING_
112 AUDIO_IO_LOGD(COLOR_GREEN "UNLOCK - FocusCB Mutex" COLOR_END);
116 CAudioSessionHandler::CAudioSessionHandler(EAudioSessionType sessionType, CAudioInfo& audioInfo, IAudioSessionEventListener* listener) :
119 __mAudioSession(sessionType),
120 __mMultimediaSession(MM_SESSION_TYPE_MEDIA),
121 __mpEventListener(listener),
125 __mAcquiredFocus(FOCUS_NONE),
126 __mReasonForChange(NULL),
127 __mAdditionalInfo(NULL),
128 __mFocusIdMutex(PTHREAD_MUTEX_INITIALIZER),
129 __mFocusCBMutex(PTHREAD_MUTEX_INITIALIZER) {
130 __mAudioInfo = audioInfo;
133 CAudioSessionHandler::~CAudioSessionHandler() {
136 CAudioError CAudioSessionHandler::__convertStreamType(EAudioSessionType type1, MMSessionType type2, int *index) {
140 assert(index != NULL);
142 if (type1 == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE) {
143 for (i = 0 ; i < sizeof(__STREAM_TYPE_TABLE_IN) / sizeof(__STREAM_TYPE_TABLE_IN[0]) ; i++) {
144 if (__STREAM_TYPE_TABLE_IN[i].type == type2) {
150 for (i = 0 ; i < sizeof(__STREAM_TYPE_TABLE_OUT) / sizeof(__STREAM_TYPE_TABLE_OUT[0]) ; i++) {
151 if (__STREAM_TYPE_TABLE_OUT[i].type == type2) {
159 RET_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "Does not support session type.");
162 RET_ERROR(CAudioError::EError::ERROR_NONE);
165 CAudioError CAudioSessionHandler::__getAsmInformation(MMSessionType *type, int *options) {
166 assert(type != NULL);
167 assert(options != NULL);
169 MMSessionType currentSession = MM_SESSION_TYPE_MEDIA;
170 int sessionOptions = 0;
172 /* Read session information */
174 if ((ret = _mm_session_util_read_information(-1, (int*)¤tSession, &sessionOptions)) < 0) {
175 if (ret == (int) MM_ERROR_INVALID_HANDLE)
176 RET_ERROR_MSG(CAudioError::EError::ERROR_INVALID_HANDLE, "Failed _mm_session_util_read_information(). Invalid handle");
178 RET_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed _mm_session_util_read_information(). Not exist");
181 *type = currentSession;
182 *options = sessionOptions;
184 RET_ERROR(CAudioError::EError::ERROR_NONE);
187 bool CAudioSessionHandler::__isFocusRequired(MMSessionType type, int options) {
188 if ((options & MM_SESSION_OPTION_PAUSE_OTHERS)
189 || ((type != MM_SESSION_TYPE_MEDIA) && (type != MM_SESSION_TYPE_MEDIA_RECORD)))
195 bool CAudioSessionHandler::__isFocusDisableReacquisitionRequired(MMSessionType type, int options) {
196 if ((type == MM_SESSION_TYPE_MEDIA) &&
197 !(options & MM_SESSION_OPTION_RESUME_BY_SYSTEM_OR_MEDIA_PAUSED))
203 bool CAudioSessionHandler::__checkNeedBlock(const char *focus_acquired_by) {
204 assert(focus_acquired_by != NULL);
206 if (!strcmp(focus_acquired_by, "alarm") ||
207 !strcmp(focus_acquired_by, "ringtone-voip") ||
208 !strcmp(focus_acquired_by, "ringtone-call") ||
209 !strcmp(focus_acquired_by, "voip") ||
210 !strcmp(focus_acquired_by, "call-voice") ||
211 !strcmp(focus_acquired_by, "call-video")) {
212 AUDIO_IO_LOGW("Blocked by session policy, focus_acquired_by[%s]", focus_acquired_by);
219 int CAudioSessionHandler::getId() {
223 int CAudioSessionHandler::getOptions() {
227 CAudioSessionHandler::EAudioSessionType CAudioSessionHandler::getAudioSession() {
228 return __mAudioSession;
231 MMSessionType CAudioSessionHandler::getMultimediaSession() {
232 return __mMultimediaSession;
235 void CAudioSessionHandler::getInternalVoipStreamInfo(sound_stream_info_h *stream_info) {
238 if ((ret = sound_manager_get_internal_voip_stream_information(stream_info))) {
239 if (ret == SOUND_MANAGER_ERROR_NO_DATA)
240 AUDIO_IO_LOGW("there's no internal voip stream info.");
242 AUDIO_IO_LOGE("failed to sound_manager_get_internal_voip_stream_information(), ret(0x%x)", ret);
248 unsigned int CAudioSessionHandler::getSubscribeId() {
249 return __mSubscribeId;
252 CAudioInfo CAudioSessionHandler::getAudioInfo() {
256 void CAudioSessionHandler::__sound_pcm_signal_cb(mm_sound_signal_name_t signal, int value, void *user_data) {
259 AUDIO_IO_LOGD("[signal:%d], [value:%d], [user_data:%p]", signal, value, user_data);
261 CAudioSessionHandler* pHandler = static_cast<CAudioSessionHandler*>(user_data);
262 if (pHandler->__mpEventListener != NULL)
263 pHandler->__mpEventListener->onSignal(pHandler, signal, value);
266 void CAudioSessionHandler::initialize() {
268 if (__mIsInit == true)
271 MMSessionType currentSession = MM_SESSION_TYPE_MEDIA;
272 int sessionOptions = 0; // Mix with others by default
274 CAudioError err = __getAsmInformation(¤tSession, &sessionOptions);
275 if (err == CAudioError::EError::ERROR_NONE) {
276 if (currentSession == MM_SESSION_TYPE_REPLACED_BY_STREAM) {
278 AUDIO_IO_LOGD("Stream info. was created outside, skip audio focus concept internally!");
280 // Session was configured before, use focus callback
282 AUDIO_IO_LOGD("Use audio focus concept internally!");
285 if (err == CAudioError::EError::ERROR_INVALID_HANDLE) {
286 // No session, No stream_info, No focus watch callback before
287 // Use focus watch callback with signal subscribe
289 int errorCode = mm_sound_subscribe_signal(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, &__mSubscribeId, __sound_pcm_signal_cb, static_cast<void*>(this));
290 if (errorCode != MM_ERROR_NONE || __mSubscribeId == 0)
291 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_subscribe_signal() err:0x%x, __mSubscribeId:%u",
292 errorCode, __mSubscribeId);
294 AUDIO_IO_LOGD("Subscribed mm_sound signal [id:%d]", __mSubscribeId);
296 sessionOptions = 0; // Mix with others by default
298 AUDIO_IO_LOGD("Use audio focus(watch) concept internally!");
301 AUDIO_IO_LOGD("Skip audio focus concept!");
304 if (__mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE) {
305 AUDIO_IO_LOGD("Set default \"Media_Record\" type");
306 currentSession = MM_SESSION_TYPE_MEDIA_RECORD;
308 AUDIO_IO_LOGD("Set default \"Media\" type");
309 currentSession = MM_SESSION_TYPE_MEDIA;
313 // Updates session information
314 __mMultimediaSession = currentSession;
315 __mOptions = sessionOptions;
317 if (this->__mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE)
318 __pcmCaptureCountInc();
323 void CAudioSessionHandler::finalize() {
325 if (__mIsInit == false)
328 if (__mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE)
329 __pcmCaptureCountDec();
333 if (__mSubscribeId > 0) {
334 AUDIO_IO_LOGD("Unsubscribed mm_sound signal [id:%d]", __mSubscribeId);
335 mm_sound_unsubscribe_signal(__mSubscribeId);
339 __mpEventListener = NULL;
344 bool CAudioSessionHandler::isSkipSession() {
345 if (__mMultimediaSession == MM_SESSION_TYPE_REPLACED_BY_STREAM ||
346 __mMultimediaSession == MM_SESSION_TYPE_VOIP ||
347 __mMultimediaSession == MM_SESSION_TYPE_CALL ||
348 __mMultimediaSession == MM_SESSION_TYPE_VIDEOCALL) {
349 AUDIO_IO_LOGD("__mMultimediaSession is [%d], skip session", __mMultimediaSession);
356 void CAudioSessionHandler::__sound_pcm_focus_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state,
357 const char *reason_for_change, int option, const char *additional_info, void *user_data) {
360 AUDIO_IO_LOGD("[id:%d], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s], [user_data:%p]",
361 id, focus_type, state, reason_for_change, additional_info, user_data);
363 /* FIXME: disable it temporarily */
364 #ifndef DISABLE_SESSION_BACK_COMP
366 CAudioSessionHandler* pHandler = static_cast<CAudioSessionHandler*>(user_data);
368 pHandler->__lockFocusCBMutex();
370 if (state == FOCUS_IS_RELEASED)
371 pHandler->__mAcquiredFocus &= ~focus_type;
372 else if (state == FOCUS_IS_ACQUIRED)
373 pHandler->__mAcquiredFocus |= focus_type;
374 pHandler->__mReasonForChange = (char *)reason_for_change;
375 pHandler->__mAdditionalInfo = (char *)additional_info;
377 if (pHandler->__mpEventListener != NULL)
378 pHandler->__mpEventListener->onInterrupt(pHandler, id, focus_type, state, reason_for_change, additional_info);
380 pHandler->__unlockFocusCBMutex();
385 void CAudioSessionHandler::__sound_pcm_focus_watch_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state,
386 const char *reason_for_change, const char *additional_info, void *user_data) {
387 AUDIO_IO_LOGD("[id:%d], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s], [user_data:%p]",
388 id, focus_type, state, reason_for_change, additional_info, user_data);
390 CAudioSessionHandler::__sound_pcm_focus_cb(-1, focus_type, state, reason_for_change, 0, additional_info, user_data);
395 void CAudioSessionHandler::registerSound() {
396 if (__mIsInit == false)
397 THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
399 if (__mUseFocus == true) {
400 __lockFocusIdMutex();
402 __unlockFocusIdMutex();
403 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Already registered [id:%d]", __mId);
408 if (__isFocusRequired(__mMultimediaSession, __mOptions)) {
411 CAudioError err = __convertStreamType(__mAudioSession, __mMultimediaSession, &index);
412 if (err != CAudioError::EError::ERROR_NONE) {
413 __unlockFocusIdMutex();
417 errorCode = mm_sound_focus_get_id(&__mId);
418 if (errorCode != MM_ERROR_NONE) {
419 __unlockFocusIdMutex();
420 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_focus_get_id() err:0x%x", errorCode);
423 // Register focus callback
424 errorCode = mm_sound_register_focus_for_session(__mId,
426 __mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE ? __STREAM_TYPE_TABLE_IN[index].name : __STREAM_TYPE_TABLE_OUT[index].name,
427 __sound_pcm_focus_cb,
428 static_cast<void*>(this));
429 if (errorCode != MM_ERROR_NONE) {
430 __unlockFocusIdMutex();
431 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_register_focus_for_session() err:0x%x", errorCode);
434 if (__isFocusDisableReacquisitionRequired(__mMultimediaSession, __mOptions)) {
435 errorCode = mm_sound_set_focus_reacquisition_for_session(__mId, false);
436 if (errorCode != MM_ERROR_NONE) {
437 __unlockFocusIdMutex();
438 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_set_focus_reacquisition() err:0x%x", errorCode);
444 AUDIO_IO_LOGD("Focus callback registered successfully [id:%d]", __mId);
445 } else if (!(__mOptions & MM_SESSION_OPTION_UNINTERRUPTIBLE)) {
446 // Register focus watch callback
447 errorCode = mm_sound_set_focus_watch_callback_for_session(getpid(), FOCUS_FOR_BOTH, __sound_pcm_focus_watch_cb, static_cast<void*>(this), &__mId);
449 __unlockFocusIdMutex();
450 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_set_focus_watch_callback_for_session() err:0x%x", errorCode);
455 AUDIO_IO_LOGD("Focus watch callback registered successfully [id:%d]", __mId);
457 __unlockFocusIdMutex();
461 void CAudioSessionHandler::unregisterSound() {
462 if (__mIsInit == false)
463 THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
465 __lockFocusIdMutex();
466 if (__mUseFocus == true && __mId >= 0) {
469 if (__isFocusRequired(__mMultimediaSession, __mOptions)) {
470 // Unregister focus callback
471 errorCode = mm_sound_unregister_focus(__mId);
472 if (errorCode != MM_ERROR_NONE) {
473 __unlockFocusIdMutex();
474 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_unregister_focus() err:0x%x", errorCode);
479 AUDIO_IO_LOGD("Focus callback unregistered successfully [id:%d]", __mId);
481 } else if (!(__mOptions & MM_SESSION_OPTION_UNINTERRUPTIBLE)) {
482 // Unregister focus watch callback.
483 errorCode = mm_sound_unset_focus_watch_callback(__mId);
485 __unlockFocusIdMutex();
486 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_unset_focus_watch_callback() err:0x%x", errorCode);
491 AUDIO_IO_LOGD("Focus watch callback unregistered successfully [id:%d]", __mId);
494 __mAcquiredFocus = FOCUS_NONE;
496 __unlockFocusIdMutex();
499 void CAudioSessionHandler::updatePlaying() {
500 if (__mIsInit == false)
501 THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
503 __lockFocusIdMutex();
504 if (!__mUseFocus || __mId < 0) {
505 __unlockFocusIdMutex();
509 if (__mUseFocus && __isFocusRequired(__mMultimediaSession, __mOptions)) {
511 int ret = MM_ERROR_NONE;
513 bool is_focus_cb_thread;
515 if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread))) {
516 __unlockFocusIdMutex();
517 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed mm_sound_focus_is_cb_thread() err:0x%x", ret);
520 if (!is_focus_cb_thread)
521 __lockFocusCBMutex();
523 if (__mAcquiredFocus == FOCUS_FOR_BOTH) {
524 AUDIO_IO_LOGW("Focus was already acquired, skip it...");
525 if (!is_focus_cb_thread)
526 __unlockFocusCBMutex();
527 __unlockFocusIdMutex();
531 focus_type |= (FOCUS_FOR_BOTH & ~__mAcquiredFocus);
532 if (__mMultimediaSession == MM_SESSION_TYPE_MEDIA)
533 ret = mm_sound_acquire_focus_with_option(__mId, (mm_sound_focus_type_e)focus_type, 1, "audio-io acquire focus"); /* option: 1 for no-resume */
535 ret = mm_sound_acquire_focus(__mId, (mm_sound_focus_type_e)focus_type, "audio-io acquire focus");
536 if (ret != MM_ERROR_NONE) {
537 if (!is_focus_cb_thread)
538 __unlockFocusCBMutex();
539 __unlockFocusIdMutex();
540 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_acquire_focus() err:0x%x", ret);
542 __mAcquiredFocus = FOCUS_FOR_BOTH;
543 AUDIO_IO_LOGD("Focus acquired successfully [id:%d]", __mId);
545 if (!is_focus_cb_thread)
546 __unlockFocusCBMutex();
549 int ret = MM_ERROR_NONE;
550 char *stream_type = NULL;
551 char *ext_info = NULL;
554 if ((ret = mm_sound_get_stream_type_of_acquired_focus(FOCUS_FOR_BOTH, &stream_type, &option, &ext_info))) {
555 __unlockFocusIdMutex();
559 AUDIO_IO_LOGD("Focus is acquired by stream_type[%s], option[%d], ext_info[%s]", stream_type, option, ext_info);
561 if (__checkNeedBlock((const char*)stream_type)) {
564 __unlockFocusIdMutex();
565 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Blocked by an acquired focus");
570 __unlockFocusIdMutex();
573 void CAudioSessionHandler::updateStop() {
574 if (__mIsInit == false)
575 THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
577 if (__mUseFocus && __isFocusRequired(__mMultimediaSession, __mOptions)) {
578 __lockFocusIdMutex();
580 int ret = MM_ERROR_NONE;
581 bool is_focus_cb_thread;
583 if ((ret = mm_sound_focus_is_cb_thread(&is_focus_cb_thread))) {
584 __unlockFocusIdMutex();
585 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed mm_sound_focus_is_cb_thread() err:0x%x", ret);
588 if (!is_focus_cb_thread)
589 __lockFocusCBMutex();
591 if (__mAcquiredFocus == FOCUS_NONE) {
592 AUDIO_IO_LOGW("Focus was already released, skip it...");
593 if (!is_focus_cb_thread)
594 __unlockFocusCBMutex();
595 __unlockFocusIdMutex();
599 if (__mMultimediaSession == MM_SESSION_TYPE_MEDIA)
600 ret = mm_sound_release_focus_with_option(__mId, (mm_sound_focus_type_e)__mAcquiredFocus, 1, "audio-io release focus"); /* option: 1 for no-resume */
602 ret = mm_sound_release_focus(__mId, (mm_sound_focus_type_e)__mAcquiredFocus, "audio-io release focus");
603 if (ret != MM_ERROR_NONE) {
604 if (!is_focus_cb_thread)
605 __unlockFocusCBMutex();
606 __unlockFocusIdMutex();
607 THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed mm_sound_release_focus() err:0x%x", ret);
609 __mAcquiredFocus = FOCUS_NONE;
610 AUDIO_IO_LOGD("Focus released successfully [id:%d]", __mId);
612 if (!is_focus_cb_thread)
613 __unlockFocusCBMutex();
615 __unlockFocusIdMutex();
619 void CAudioSessionHandler::disableSessionHandler() {
620 CAudioSessionHandler::updateStop();
621 CAudioSessionHandler::unregisterSound();
623 CAudioSessionHandler::__mUseFocus = false;
627 * class IAudioSessionEventListener
629 IAudioSessionEventListener::EInterruptCode IAudioSessionEventListener::convertInterruptedCode(int code, const char *reason_for_change) {
630 EInterruptCode e = EInterruptCode::INTERRUPT_BY_MEDIA;
633 case FOCUS_IS_ACQUIRED:
634 e = EInterruptCode::INTERRUPT_COMPLETED;
637 case FOCUS_IS_RELEASED:
638 if (!strcmp(reason_for_change, "media")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
639 if (!strcmp(reason_for_change, "radio")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
640 if (!strcmp(reason_for_change, "loopback")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
641 if (!strcmp(reason_for_change, "system")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
642 if (!strcmp(reason_for_change, "alarm")) e = EInterruptCode::INTERRUPT_BY_ALARM;
643 if (!strcmp(reason_for_change, "notification")) e = EInterruptCode::INTERRUPT_BY_NOTIFICATION;
644 if (!strcmp(reason_for_change, "emergency")) e = EInterruptCode::INTERRUPT_BY_EMERGENCY;
645 if (!strcmp(reason_for_change, "voice-information")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
646 if (!strcmp(reason_for_change, "voice-recognition")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
647 if (!strcmp(reason_for_change, "voice-recognition-service")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
648 if (!strcmp(reason_for_change, "ringtone-voip")) e = EInterruptCode::INTERRUPT_BY_CALL;
649 if (!strcmp(reason_for_change, "ringtone-call")) e = EInterruptCode::INTERRUPT_BY_CALL;
650 if (!strcmp(reason_for_change, "voip")) e = EInterruptCode::INTERRUPT_BY_CALL;
651 if (!strcmp(reason_for_change, "call-voice")) e = EInterruptCode::INTERRUPT_BY_CALL;
652 if (!strcmp(reason_for_change, "call-video")) e = EInterruptCode::INTERRUPT_BY_CALL;