Seperate sound stream ducking handle

Change-Id: I029e7a7f2483aaf377a3229c5084d55577cc639c

diff --git a/server/ttsd_player.c b/server/ttsd_player.c
index 688bd6a..f1594c1 100644 (file)
--- a/server/ttsd_player.c
+++ b/server/ttsd_player.c
@@ -81,9 +81,12 @@ static audio_out_h g_audio_h;
 
 static sound_stream_info_h g_stream_info_h;
 
-static sound_stream_ducking_h g_stream_ducking;
+static sound_stream_ducking_h g_media_stream_ducking;
+static sound_stream_ducking_h g_system_stream_ducking;
+static sound_stream_ducking_h g_notification_stream_ducking;
+static sound_stream_ducking_h g_alarm_stream_ducking;
 
-static bool ducking_flag;
+// static bool ducking_flag;
 
 #define SND_MGR_DUCKING_DURATION 500
 
@@ -243,53 +246,72 @@ void __player_focus_state_watch_cb(int id, sound_stream_focus_mask_e focus_mask,
 void __sound_stream_ducking_state_changed_cb(sound_stream_ducking_h stream_ducking, bool is_ducked, void *user_data)
 {
        SLOG(LOG_DEBUG, tts_tag(), "@@@ ducking state changed cb");
-
        SLOG(LOG_DEBUG, tts_tag(), "[Player] is ducked : %d", is_ducked);
-
-       ducking_flag = true;
+       // ducking_flag = true;
        return;
 }
 
-static void __change_background_volume()
+static char* __get_ducking_stream(sound_stream_type_e stream_type)
+{
+       if (SOUND_STREAM_TYPE_MEDIA == stream_type)
+               return "Media stream";
+       else if (SOUND_STREAM_TYPE_SYSTEM == stream_type)
+               return "System stream";
+       else if (SOUND_STREAM_TYPE_NOTIFICATION == stream_type)
+               return "Notification stream";
+       else if (SOUND_STREAM_TYPE_ALARM == stream_type)
+               return "Alarm stream";
+       return "Non matched stream";
+}
+
+static int __activate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h)
 {
-       int ret = SOUND_MANAGER_ERROR_NONE;
        bool is_ducked = false;
-       ret = sound_manager_is_ducked(g_stream_ducking, &is_ducked);
+       int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked);
        if (is_ducked) {
-               SLOG(LOG_DEBUG, tts_tag(), "[Player] The background volume is already ducked");
-               return;
-       }
-
-       ducking_flag = false;
-       ret = sound_manager_activate_ducking(g_stream_ducking, SND_MGR_DUCKING_DURATION, g_bg_volume_ratio);
-       if (SOUND_MANAGER_ERROR_NONE != ret) {
-               SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to activate ducking");
-               return;
+               SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already ducked", __get_ducking_stream(stream_type));
        } else {
-               SLOG(LOG_DEBUG, tts_tag(), "[Player] Activate ducking");
+               ret = sound_manager_activate_ducking(stream_ducking_h, SND_MGR_DUCKING_DURATION, g_bg_volume_ratio);
+               if (SOUND_MANAGER_ERROR_NONE != ret) {
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to activate ducking for %s", __get_ducking_stream(stream_type));
+               } else {
+                       SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Activate ducking for %s", __get_ducking_stream(stream_type));
+               }
        }
+       return ret;
+}
 
-       while (ducking_flag == false) {
-               usleep(10000);
-               SLOG(LOG_DEBUG, tts_tag(), "ducking waiting");
-       }
+static void __change_background_volume()
+{
+       __activate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking);
+       __activate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking);
+       __activate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking);
+       __activate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking);
 }
 
-static void __recover_background_volume()
+static int __deactivate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h)
 {
-       int ret = SOUND_MANAGER_ERROR_NONE;
        bool is_ducked = false;
-       ret = sound_manager_is_ducked(g_stream_ducking, &is_ducked);
+       int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked);
        if (!is_ducked) {
-               SLOG(LOG_DEBUG, tts_tag(), "[Player] The background volume is already recovered");
-               return;
+               SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already recovered from ducking", __get_ducking_stream(stream_type));
+       } else {
+               ret = sound_manager_deactivate_ducking(stream_ducking_h);
+               if (SOUND_MANAGER_ERROR_NONE != ret) {
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to deactivate ducking for %s", __get_ducking_stream(stream_type));
+               } else {
+                       SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Deactivate ducking for %s", __get_ducking_stream(stream_type));
+               }
        }
+       return ret;
+}
 
-       ret = sound_manager_deactivate_ducking(g_stream_ducking);
-       if (SOUND_MANAGER_ERROR_NONE != ret)
-               SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to deactivate ducking");
-       else
-               SLOG(LOG_WARN, tts_tag(), "[Player] Deactivate ducking");
+static void __recover_background_volume()
+{
+       __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking);
+       __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking);
+       __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking);
+       __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking);
 }
 
 static int __create_audio_out(ttse_audio_type_e type, int rate)
@@ -357,6 +379,9 @@ static void __end_play_thread(void *data, Ecore_Thread *thread)
 
 static void __set_policy_for_playing(int volume)
 {
+
+       __change_background_volume();
+
        /* Set stream info */
        int ret;
        ttsd_mode_e mode = ttsd_get_mode();
@@ -381,8 +406,6 @@ static void __set_policy_for_playing(int volume)
                SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
        }
 
-       __change_background_volume();
-
        SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] set policy for playing");
 
        return;
@@ -815,6 +838,43 @@ static void __play_thread(void *data, Ecore_Thread *thread)
        }
 }
 
+int __create_ducking_handle(void)
+{
+       int ret = -1;
+       if (NULL == g_media_stream_ducking) {
+               ret = sound_manager_create_stream_ducking(SOUND_STREAM_TYPE_MEDIA, __sound_stream_ducking_state_changed_cb, NULL, &g_media_stream_ducking);
+               if (SOUND_MANAGER_ERROR_NONE != ret)
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for type media, ret(%d)", ret);
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created");
+       }
+       if (NULL == g_system_stream_ducking) {
+               ret = sound_manager_create_stream_ducking(SOUND_TYPE_SYSTEM, __sound_stream_ducking_state_changed_cb, NULL, &g_system_stream_ducking);
+               if (SOUND_MANAGER_ERROR_NONE != ret)
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for system type, ret(%d)", ret);
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created");
+       }
+
+       if (NULL == g_notification_stream_ducking) {
+               ret = sound_manager_create_stream_ducking(SOUND_TYPE_NOTIFICATION, __sound_stream_ducking_state_changed_cb, NULL, &g_notification_stream_ducking);
+               if (SOUND_MANAGER_ERROR_NONE != ret)
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for notification type, ret(%d)", ret);
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created");
+       }
+
+       if (NULL == g_alarm_stream_ducking) {
+               ret = sound_manager_create_stream_ducking(SOUND_TYPE_ALARM, __sound_stream_ducking_state_changed_cb, NULL, &g_alarm_stream_ducking);
+               if (SOUND_MANAGER_ERROR_NONE != ret)
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for alarm type, ret(%d)", ret);
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created");
+       }
+
+       return ret;
+}
+
 /*
 * Player Interfaces
 */
@@ -858,11 +918,12 @@ int ttsd_player_init()
                SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback");
        }
 
-       ret = sound_manager_create_stream_ducking(SOUND_STREAM_TYPE_MEDIA, __sound_stream_ducking_state_changed_cb, NULL, &g_stream_ducking);
-       if (SOUND_MANAGER_ERROR_NONE != ret)
-               SLOG(LOG_ERROR, tts_tag(), "[Player WARNING] Fail to create stream ducking");
-       else
-               SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream ducking");
+       ret = __create_ducking_handle();
+       if (SOUND_MANAGER_ERROR_NONE != ret) {
+               SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create ducking handle, ret(%d)", ret);
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Create ducking handle");
+       }
 
        ecore_thread_max_set(1);
 
@@ -878,6 +939,47 @@ int ttsd_player_init()
        return 0;
 }
 
+int __destroy_ducking_handle(void)
+{
+       int ret = -1;
+       if (g_media_stream_ducking) {
+               ret = sound_manager_destroy_stream_ducking(g_media_stream_ducking);
+               if (SOUND_MANAGER_ERROR_NONE != ret)
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy media stream ducking, ret(%d)", ret);
+               g_media_stream_ducking = NULL;
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created");
+       }
+
+       if (g_system_stream_ducking) {
+               ret = sound_manager_destroy_stream_ducking(g_system_stream_ducking);
+               if (SOUND_MANAGER_ERROR_NONE != ret)
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy system stream ducking, ret(%d)", ret);
+               g_system_stream_ducking = NULL;
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created");
+       }
+
+       if (g_notification_stream_ducking) {
+               ret = sound_manager_destroy_stream_ducking(g_notification_stream_ducking);
+               if (SOUND_MANAGER_ERROR_NONE != ret)
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy notification stream ducking, ret(%d)", ret);
+               g_notification_stream_ducking = NULL;   
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created");
+       }
+
+       if (g_alarm_stream_ducking) {
+               ret = sound_manager_destroy_stream_ducking(g_alarm_stream_ducking);
+               if (SOUND_MANAGER_ERROR_NONE != ret)
+                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy alarm stream ducking, ret(%d)", ret);
+               g_alarm_stream_ducking = NULL;
+       } else {
+               SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created");
+       }
+       return ret;
+}
+
 int ttsd_player_release(void)
 {
        if (false == g_player_init) {
@@ -927,9 +1029,9 @@ int ttsd_player_release(void)
                SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb");
        }
 
-       ret = sound_manager_destroy_stream_ducking(g_stream_ducking);
+       ret = __destroy_ducking_handle();
        if (SOUND_MANAGER_ERROR_NONE != ret)
-               SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream ducking");
+               SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream ducking, ret(%d)", ret);
        else
                SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream ducking");