src/FMedia_AudioRouteManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License)
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 #include <iostream>
  18 #include <pthread.h>
  19 #include <sound_manager.h>
  20 #include <FBaseCol.h>
  21 #include <FBaseRt.h>
  22 #include <FBaseSysLog.h>
  23 #include <FMediaAudioManagerTypes.h>
  24 #include <FMediaIAudioRouteEventListener.h>
  25 #include "FMedia_AudioManagerConvert.h"
  26 #include "FMedia_AudioRouteManagerImpl.h"
  27
  28
  29 using namespace Tizen::Base;
  30 using namespace Tizen::Base::Runtime;
  31 using namespace Tizen::Base::Collection;
  32
  33 namespace Tizen { namespace Media
  34 {
  35
  36 _AudioRouteManagerImpl* _AudioRouteManagerImpl::__pAudioRouteImpl = null;
  37
  38 _AudioRouteManagerImpl::_AudioRouteManagerImpl(void)
  39         : __pListener(null)
  40         , __pSingleAudioRouteListner(null)
  41 {
  42
  43 }
  44
  45 _AudioRouteManagerImpl::~_AudioRouteManagerImpl(void)
  46 {
  47         __pSingleAudioRouteListner = null;
  48         sound_manager_unset_available_route_changed_cb();
  49         sound_manager_unset_active_device_changed_cb();
  50 }
  51
  52 void
  53 _AudioRouteManagerImpl::InitAudioRouteManagerImpl(void)
  54 {
  55         static _AudioRouteManagerImpl instance;
  56         __pAudioRouteImpl = &instance;
  57 }
  58
  59 _AudioRouteManagerImpl*
  60 _AudioRouteManagerImpl::GetInstance(void)
  61 {
  62         result r = E_SUCCESS;
  63         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
  64         if (__pAudioRouteImpl == null)
  65         {
  66                 pthread_once(&onceBlock, InitAudioRouteManagerImpl);
  67                 r = __pAudioRouteImpl->Construct();
  68                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, ,r, "[%s] Propagating.", GetErrorMessage(r));
  69         }
  70         return __pAudioRouteImpl;
  71 CATCH:
  72         __pAudioRouteImpl = null;
  73         return null;
  74 }
  75
  76 result
  77 _AudioRouteManagerImpl::Construct(void)
  78 {
  79         result r = E_SUCCESS;
  80         int ret = 0;
  81
  82         __pAudioRouteEvent.reset(new (std::nothrow) _AudioRouteEvent);
  83         SysTryCatch(NID_MEDIA, __pAudioRouteEvent.get(), r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  84         r = __pAudioRouteEvent->Construct();
  85         SysTryCatch(NID_MEDIA, r == E_SUCCESS , , r, "[%s] Propagating.", GetErrorMessage(r));
  86
  87         ret = sound_manager_set_available_route_changed_cb(SoundAvailableRouteChangedCallback, this);
  88         r = _AudioManagerConvert::CovertSoundManagerError2Result(ret);
  89         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r,
  90                 "[%s] Failed to perform sound_manager_set_available_route_changed_cb operation with error code : %x", GetErrorMessage(r), ret);
  91
  92         ret = sound_manager_set_active_device_changed_cb(SoundActiveDeviceChangedCallback, this);
  93         r = _AudioManagerConvert::CovertSoundManagerError2Result(ret);
  94         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r,
  95                 "[%s] Failed to perform sound_manager_set_active_device_changed_cb operation with error code : %x", GetErrorMessage(r), ret);
  96         return r;
  97 CATCH:
  98         return r;
  99 }
 100
 101 bool
 102 _AudioRouteManagerImpl::SoundAvailableRouteCallback(sound_route_e route, void* pUserData)
 103 {
 104         AudioRouteInfo* pAudioDevice = null;
 105         pAudioDevice = new (std::nothrow) AudioRouteInfo(INPUT_AUDIO_DEVICE_NONE, OUTPUT_AUDIO_DEVICE_NONE);
 106         SysTryReturn(NID_MEDIA, pAudioDevice != null, false, E_OUT_OF_MEMORY, " [E_OUT_OF_MEMORY] Memory allocation failed.");
 107         IList* pAudioDeviceList = null;
 108         pAudioDeviceList = (IList *)pUserData;
 109         if ((sound_device_out_e)route < SOUND_DEVICE_OUT_SPEAKER)
 110         //route returned is an Input device
 111         {
 112                 pAudioDevice->SetInputAudioDevice((ConvertSoundIn2InputAudio((unsigned int)route)));
 113         }
 114         else if (route & (route - 1))
 115         // route returned is a combination of output and output
 116         // if it is a power of 2 then its a output device only
 117         {
 118                 ConvertRoute2AudioDevice((unsigned int)route, *pAudioDevice);
 119         }
 120         else
 121         // route returned is a output device
 122         {
 123                 pAudioDevice->SetOutputAudioDevice((ConvertSoundOut2OutputAudio((unsigned int)route)));
 124         }
 125         pAudioDeviceList->Add(*pAudioDevice);
 126         return true;
 127 }
 128
 129 void
 130 _AudioRouteManagerImpl::SoundAvailableRouteChangedCallback(sound_route_e route, bool available, void* pUserData)
 131 {
 132         result r = E_SUCCESS;
 133         AudioRouteInfo audioRouteInfo(INPUT_AUDIO_DEVICE_NONE, OUTPUT_AUDIO_DEVICE_NONE);
 134         _AudioRouteManagerImpl* pAudioRouteImpl = (_AudioRouteManagerImpl *)pUserData;
 135         SysTryReturn(NID_MEDIA, pAudioRouteImpl, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. The value of pUserData is null.");
 136
 137         if ((sound_device_out_e)route < SOUND_DEVICE_OUT_SPEAKER)
 138         {
 139                 audioRouteInfo.SetInputAudioDevice((ConvertSoundIn2InputAudio((unsigned int)route)));
 140         }
 141         else if (route & (route - 1))
 142         {
 143                 ConvertRoute2AudioDevice((unsigned int)route, audioRouteInfo);
 144         }
 145         else
 146         {
 147                 audioRouteInfo.SetOutputAudioDevice((ConvertSoundOut2OutputAudio((unsigned int)route)));
 148         }
 149         SysLog(NID_MEDIA, "Input device is %d, Output device is %d and Available is %d", audioRouteInfo.GetInputAudioDevice(), audioRouteInfo.GetOutputAudioDevice(), available);
 150
 151         _AudioRouteEventArg* pRouteEventArg = new (std::nothrow) _AudioRouteEventArg;
 152         SysTryReturn(NID_MEDIA, pRouteEventArg, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 153         if (available)
 154         {
 155                 pRouteEventArg->SetEventType(_AUDIO_ROUTE_EVENT_ADDED);
 156         }
 157         else
 158         {
 159                 pRouteEventArg->SetEventType(_AUDIO_ROUTE_EVENT_REMOVED);
 160         }
 161         pRouteEventArg->SetAudioRouteInfo(audioRouteInfo);
 162         r = pAudioRouteImpl->__pAudioRouteEvent->FireAsync(*pRouteEventArg);
 163         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s] Failed to perform FireAsync operation.", GetErrorMessage(r));
 164 }
 165
 166 void
 167 _AudioRouteManagerImpl::SoundActiveDeviceChangedCallback(sound_device_in_e in, sound_device_out_e out, void* pUserData)
 168 {
 169         result r = E_SUCCESS;
 170         AudioRouteInfo audioRouteInfo(INPUT_AUDIO_DEVICE_NONE, OUTPUT_AUDIO_DEVICE_NONE);
 171
 172         _AudioRouteManagerImpl* pAudioRouteImpl = (_AudioRouteManagerImpl *)pUserData;
 173         SysTryReturn(NID_MEDIA, pAudioRouteImpl, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred. The value of pUserData is null.");
 174
 175         audioRouteInfo.SetInputAudioDevice(ConvertSoundIn2InputAudio((unsigned int)in));
 176         audioRouteInfo.SetOutputAudioDevice(ConvertSoundOut2OutputAudio((unsigned int)out));
 177
 178         _AudioRouteEventArg* pRouteEventArg = new (std::nothrow) _AudioRouteEventArg;
 179         SysTryReturn(NID_MEDIA, pRouteEventArg, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 180         pRouteEventArg->SetEventType(_AUDIO_ROUTE_EVENT_ACTIVE_CHANGED);
 181         pRouteEventArg->SetAudioRouteInfo(audioRouteInfo);
 182         r = pAudioRouteImpl->__pAudioRouteEvent->FireAsync(*pRouteEventArg);
 183         SysTryLog(NID_MEDIA, r == E_SUCCESS, "[%s]FireAsync failed", GetErrorMessage(r));
 184 }
 185
 186 result
 187 _AudioRouteManagerImpl::SetAudioRouteEventListener(IAudioRouteEventListener* pListener)
 188 {
 189         result r = E_SUCCESS;
 190         SysTryReturn(NID_MEDIA, __pAudioRouteEvent != null, E_SYSTEM, E_SYSTEM,
 191                 "[E_SYSTEM] A error has been occurred. The value of __pAudioRouteEvent is null.");
 192         if (__pSingleAudioRouteListner != null)
 193         {
 194                 r = __pAudioRouteEvent->RemoveListener(*__pSingleAudioRouteListner);
 195                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] RemoveListener() failed", GetErrorMessage(r));
 196                 __pSingleAudioRouteListner = null;
 197         }
 198         if (pListener != null)
 199         {
 200                 __pSingleAudioRouteListner = pListener;
 201                 return __pAudioRouteEvent->AddListener(*pListener);
 202         }
 203         return r;
 204 }
 205
 206
 207 String
 208 _AudioRouteManagerImpl::GetActiveBluetoothA2dpName(void)
 209 {
 210         int ret = SOUND_MANAGER_ERROR_NONE;
 211         result r = E_SUCCESS;
 212         bool isConnected = false;
 213         char* pBtName = null;
 214         ret = sound_manager_get_a2dp_status(&isConnected, &pBtName);
 215         r = _AudioManagerConvert::CovertSoundManagerError2Result(ret);
 216         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r,
 217                 "[%s] Failed to perform sound_manager_get_a2dp_status operation with error code : 0x%x", GetErrorMessage(r), ret);
 218
 219         if (isConnected == true)
 220         {
 221                 if (pBtName != null)
 222                 {
 223                         String stBtName(pBtName);
 224                         free(pBtName);
 225                         return stBtName;
 226                 }
 227         }
 228         else
 229         {
 230                 SetLastResult(E_DEVICE_UNAVAILABLE);
 231                 return String(L"");
 232         }
 233 CATCH:
 234         return String(L"");
 235 }
 236
 237 AudioStreamType
 238 _AudioRouteManagerImpl::GetActiveAudioStreamType(void)
 239 {
 240         result r = E_SUCCESS;
 241         int ret = SOUND_MANAGER_ERROR_NONE;
 242         sound_type_e soundType = SOUND_TYPE_SYSTEM;
 243         AudioStreamType audioStreamType = AUDIO_STREAM_TYPE_NO_SOUND;
 244         ret = sound_manager_get_current_sound_type(&soundType);
 245         SysTryCatch(NID_MEDIA, ret == SOUND_MANAGER_ERROR_NONE, , E_SYSTEM,
 246                         "[E_SYSTEM] A system error has been occurred. Failed to perform sound_manager_get_current_sound_type operation with error code : 0x%x", ret);
 247         r = _AudioManagerConvert::CovertSoundManagerError2Result(ret);
 248         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r,
 249                 "[%s] Failed to perform sound_manager_get_a2dp_status operation with error code : 0x%x", GetErrorMessage(r), ret);
 250
 251         switch (soundType)
 252         {
 253         case SOUND_TYPE_SYSTEM:
 254                 audioStreamType = AUDIO_STREAM_TYPE_SYSTEM;
 255                 break;
 256         case SOUND_TYPE_NOTIFICATION:
 257                 audioStreamType = AUDIO_STREAM_TYPE_NOTIFICATION;
 258                 break;
 259         case SOUND_TYPE_ALARM:
 260                 audioStreamType = AUDIO_STREAM_TYPE_ALARM;
 261                 break;
 262         case SOUND_TYPE_RINGTONE:
 263                 audioStreamType = AUDIO_STREAM_TYPE_RINGTONE;
 264                 break;
 265         case SOUND_TYPE_MEDIA:
 266                 audioStreamType = AUDIO_STREAM_TYPE_MEDIA;
 267                 break;
 268         case SOUND_TYPE_CALL:
 269                 audioStreamType = AUDIO_STREAM_TYPE_CALL;
 270                 break;
 271         default:
 272                 audioStreamType = AUDIO_STREAM_TYPE_NO_SOUND;
 273                 break;
 274         }
 275 CATCH:
 276         return audioStreamType;
 277 }
 278
 279 Tizen::Base::Collection::IList*
 280 _AudioRouteManagerImpl::GetAvailableAudioRouteListN()
 281 {
 282         result r = E_SUCCESS;
 283         int ret = SOUND_MANAGER_ERROR_NONE;
 284         IList* pAudioDeviceList = null;
 285         pAudioDeviceList = new (std::nothrow) ArrayList();
 286         SysTryReturn(NID_MEDIA, pAudioDeviceList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 287         ret = sound_manager_foreach_available_route(SoundAvailableRouteCallback, pAudioDeviceList);
 288         r = _AudioManagerConvert::CovertSoundManagerError2Result(ret);
 289         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to perform sound_manager_call_session_destroy operation.", GetErrorMessage(r));
 290         return pAudioDeviceList;
 291 CATCH:
 292         pAudioDeviceList->RemoveAll();
 293         delete pAudioDeviceList;
 294         pAudioDeviceList = null;
 295         return null;
 296 }
 297
 298 bool
 299 _AudioRouteManagerImpl::IsAudioRouteAvailable(const AudioRouteInfo& device)
 300 {
 301         unsigned int route = 0;
 302         if (device.GetInputAudioDevice() == INPUT_AUDIO_DEVICE_NONE)
 303         {
 304                 route = ConvertOutputAudio2SoundOut(device.GetOutputAudioDevice());
 305         }
 306         else if (device.GetOutputAudioDevice() == OUTPUT_AUDIO_DEVICE_NONE)
 307         {
 308                 route = ConvertInputAudio2SoundIn(device.GetInputAudioDevice());
 309         }
 310         else
 311         {
 312                 route = ConvertAudioDevice2Route(device);
 313         }
 314         if (route == 0)
 315         {
 316                 SetLastResult(E_INVALID_ARG);
 317                 return false;
 318         }
 319
 320         return sound_manager_is_route_available((sound_route_e)route);
 321 }
 322
 323 result
 324 _AudioRouteManagerImpl::SetActiveAudioRoute(const AudioRouteInfo& device)
 325 {
 326         result r = E_SUCCESS;
 327         int ret = SOUND_MANAGER_ERROR_NONE;
 328         unsigned int route = 0;
 329         if (device.GetInputAudioDevice() == INPUT_AUDIO_DEVICE_NONE)
 330         {
 331                 route = ConvertOutputAudio2SoundOut(device.GetOutputAudioDevice());
 332         }
 333         else if (device.GetOutputAudioDevice() == OUTPUT_AUDIO_DEVICE_NONE)
 334         {
 335                 route = ConvertInputAudio2SoundIn(device.GetInputAudioDevice());
 336         }
 337         else
 338         {
 339                 route = ConvertAudioDevice2Route(device);
 340         }
 341         SysTryReturn(NID_MEDIA, route != 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. The value of device is wrong");
 342         bool routeAvailable = sound_manager_is_route_available((sound_route_e)route);
 343         SysTryReturn(NID_MEDIA, routeAvailable == true, E_SYSTEM, E_SYSTEM,
 344                 "[E_SYSTEM] Failed to perform sound_manager_is_route_available operation.");
 345         ret = sound_manager_set_active_route((sound_route_e)route);
 346         r = _AudioManagerConvert::CovertSoundManagerError2Result(ret);
 347         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Failed to perform sound_manager_set_active_route operation with error code : 0x%x", GetErrorMessage(r), ret);
 348         return E_SUCCESS;
 349 }
 350
 351 AudioRouteInfo
 352 _AudioRouteManagerImpl::GetActiveAudioRoute(void)
 353 {
 354         result r = E_SUCCESS;
 355         int ret = SOUND_MANAGER_ERROR_NONE;
 356         sound_device_in_e in = SOUND_DEVICE_IN_MIC;
 357         sound_device_out_e out = SOUND_DEVICE_OUT_SPEAKER;
 358         ret = sound_manager_get_active_device(&in, &out);
 359         r = _AudioManagerConvert::CovertSoundManagerError2Result(ret);
 360         SysTryReturn(NID_MEDIA, r == E_SUCCESS, AudioRouteInfo(INPUT_AUDIO_DEVICE_NONE, OUTPUT_AUDIO_DEVICE_NONE),
 361                         r, "[%s] Failed to perform sound_manager_get_active_device operation with error code : 0x%x", GetErrorMessage(r), ret);
 362         return AudioRouteInfo(ConvertSoundIn2InputAudio((unsigned int)in), ConvertSoundOut2OutputAudio((unsigned int)out));
 363 }
 364
 365 InputAudioDevice
 366 _AudioRouteManagerImpl::ConvertSoundIn2InputAudio(unsigned int route)
 367 {
 368         switch (route)
 369         {
 370         case SOUND_ROUTE_IN_MIC:
 371                 return INPUT_AUDIO_DEVICE_MIC;
 372         case SOUND_ROUTE_IN_WIRED_ACCESSORY:
 373                 return INPUT_AUDIO_DEVICE_WIRED_ACCESSORY;
 374         default:
 375                 return INPUT_AUDIO_DEVICE_NONE;
 376         }
 377 }
 378
 379 unsigned int
 380 _AudioRouteManagerImpl::ConvertInputAudio2SoundIn(InputAudioDevice input)
 381 {
 382         switch (input)
 383         {
 384         case INPUT_AUDIO_DEVICE_MIC:
 385                 return SOUND_ROUTE_IN_MIC;
 386         case INPUT_AUDIO_DEVICE_WIRED_ACCESSORY:
 387                 return SOUND_ROUTE_IN_WIRED_ACCESSORY;
 388         default:
 389                 return 0;
 390         }
 391 }
 392
 393 unsigned int
 394 _AudioRouteManagerImpl::ConvertOutputAudio2SoundOut(OutputAudioDevice output)
 395 {
 396         switch (output)
 397         {
 398         case OUTPUT_AUDIO_DEVICE_SPEAKER:
 399                 return SOUND_ROUTE_OUT_SPEAKER;
 400         case OUTPUT_AUDIO_DEVICE_WIRED_ACCESSORY:
 401                 return SOUND_ROUTE_OUT_WIRED_ACCESSORY;
 402         case OUTPUT_AUDIO_DEVICE_BT_A2DP:
 403                 return SOUND_ROUTE_OUT_BLUETOOTH;
 404         case OUTPUT_AUDIO_DEVICE_DOCK:
 405                 return  SOUND_ROUTE_OUT_DOCK;
 406         case OUTPUT_AUDIO_DEVICE_HDMI:
 407                 return SOUND_ROUTE_OUT_HDMI;
 408         case OUTPUT_AUDIO_DEVICE_WFD:
 409                 return  SOUND_ROUTE_OUT_WFD ;
 410         case OUTPUT_AUDIO_DEVICE_USB_AUDIO:
 411                 return SOUND_ROUTE_OUT_USB_AUDIO;
 412         default:
 413                 return 0;
 414         }
 415 }
 416
 417 unsigned int
 418 _AudioRouteManagerImpl::ConvertAudioDevice2Route(const AudioRouteInfo &device)
 419 {
 420         InputAudioDevice in = device.GetInputAudioDevice();
 421         OutputAudioDevice out = device.GetOutputAudioDevice();
 422         if ((in == INPUT_AUDIO_DEVICE_MIC) && (out == OUTPUT_AUDIO_DEVICE_RECEIVER))
 423         {
 424                 return SOUND_ROUTE_IN_MIC_OUT_RECEIVER;
 425         }
 426         if ((in == INPUT_AUDIO_DEVICE_MIC) && (out == OUTPUT_AUDIO_DEVICE_SPEAKER))
 427         {
 428                 return SOUND_ROUTE_IN_MIC_OUT_SPEAKER;
 429         }
 430         if ((in == INPUT_AUDIO_DEVICE_MIC) && (out == OUTPUT_AUDIO_DEVICE_WIRED_ACCESSORY))
 431         {
 432                 return SOUND_ROUTE_IN_MIC_OUT_HEADPHONE;
 433         }
 434         if ((in == INPUT_AUDIO_DEVICE_WIRED_ACCESSORY) && (out == OUTPUT_AUDIO_DEVICE_WIRED_ACCESSORY))
 435         {
 436                 return SOUND_ROUTE_INOUT_HEADSET;
 437         }
 438         if ((in == INPUT_AUDIO_DEVICE_BT_SCO) && (out == OUTPUT_AUDIO_DEVICE_BT_SCO))
 439         {
 440                 return SOUND_ROUTE_INOUT_BLUETOOTH;
 441         }
 442         return 0;
 443 }
 444
 445 OutputAudioDevice
 446 _AudioRouteManagerImpl::ConvertSoundOut2OutputAudio(unsigned int route)
 447 {
 448         switch (route)
 449         {
 450         case SOUND_ROUTE_OUT_SPEAKER:
 451                 return OUTPUT_AUDIO_DEVICE_SPEAKER;
 452         case SOUND_ROUTE_OUT_WIRED_ACCESSORY:
 453                 return OUTPUT_AUDIO_DEVICE_WIRED_ACCESSORY;
 454         case SOUND_ROUTE_OUT_BLUETOOTH:
 455                 return OUTPUT_AUDIO_DEVICE_BT_A2DP;
 456         case SOUND_ROUTE_OUT_DOCK:
 457                 return OUTPUT_AUDIO_DEVICE_DOCK;
 458         case SOUND_ROUTE_OUT_HDMI:
 459                 return OUTPUT_AUDIO_DEVICE_HDMI;
 460         case SOUND_ROUTE_OUT_WFD:
 461                 return OUTPUT_AUDIO_DEVICE_WFD;
 462         case SOUND_ROUTE_OUT_USB_AUDIO:
 463                 return OUTPUT_AUDIO_DEVICE_USB_AUDIO;
 464         default:
 465                 return OUTPUT_AUDIO_DEVICE_NONE;
 466         }
 467 }
 468
 469 void
 470 _AudioRouteManagerImpl::ConvertRoute2AudioDevice(unsigned int route, AudioRouteInfo& audioRouteInfo)
 471 {
 472         switch (route)
 473         {
 474         case SOUND_ROUTE_IN_MIC_OUT_RECEIVER:
 475                 audioRouteInfo.SetInputAudioDevice(INPUT_AUDIO_DEVICE_MIC);
 476                 audioRouteInfo.SetOutputAudioDevice(OUTPUT_AUDIO_DEVICE_RECEIVER);
 477                 break;
 478         case SOUND_ROUTE_IN_MIC_OUT_SPEAKER:
 479                 audioRouteInfo.SetInputAudioDevice(INPUT_AUDIO_DEVICE_MIC);
 480                 audioRouteInfo.SetOutputAudioDevice(OUTPUT_AUDIO_DEVICE_SPEAKER);
 481                 break;
 482         case SOUND_ROUTE_IN_MIC_OUT_HEADPHONE:
 483                 audioRouteInfo.SetInputAudioDevice(INPUT_AUDIO_DEVICE_MIC);
 484                 audioRouteInfo.SetOutputAudioDevice(OUTPUT_AUDIO_DEVICE_WIRED_ACCESSORY);
 485                 break;
 486         case SOUND_ROUTE_INOUT_HEADSET:
 487                 audioRouteInfo.SetInputAudioDevice(INPUT_AUDIO_DEVICE_WIRED_ACCESSORY);
 488                 audioRouteInfo.SetOutputAudioDevice(OUTPUT_AUDIO_DEVICE_WIRED_ACCESSORY);
 489                 break;
 490         case SOUND_ROUTE_INOUT_BLUETOOTH:
 491                 audioRouteInfo.SetInputAudioDevice(INPUT_AUDIO_DEVICE_BT_SCO);
 492                 audioRouteInfo.SetOutputAudioDevice(OUTPUT_AUDIO_DEVICE_BT_SCO);
 493                 break;
 494         default:
 495                 break;
 496         }
 497 }
 498
 499 };
 500 };              //Tizen::Media