src/FMedia_AudioRecorderImpl.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
  18 /**
  19  * @file                 FMedia_AudioRecorderImpl.cpp
  20  * @brief                This file contains the implementation of the _AudioRecorder_Impl class.
  21  *
  22  */
  23
  24
  25 #include <FBaseSysLog.h>
  26 #include <FBaseInteger.h>
  27 #include <FBase_StringConverter.h>
  28 #include <FMediaAudioRecorder.h>
  29 #include "FMedia_MediaUtil.h"
  30 #include "FMedia_AudioRecorderImpl.h"
  31 #include "FMedia_AudioRecorderEvent.h"
  32 #include "FMedia_RecorderUtil.h"
  33 #include "FMedia_CapabilityImpl.h"
  34 #include "FMedia_RecorderCapability.h"
  35 #include "FMedia_RecorderManager.h"
  36 #include "FMedia_CamPtrUtil.h"
  37 #include "FMedia_AudioStreamCoordinator.h"
  38 #include "FMedia_RecorderRef.h"
  39
  40 using namespace Tizen::Base;
  41 using namespace Tizen::Base::Collection;
  42 using namespace Tizen::Io;
  43
  44 namespace Tizen { namespace Media
  45 {
  46 static const int _RELOAD_FORMAT = 0x1;
  47 static const int _RELOAD_QUALITY = 0x1 << 1;
  48 static const int _RELOAD_MAX_TIME = 0x1 << 2;
  49 static const int _RELOAD_INIT = 0x1 << 3;
  50
  51 typedef int (*_AudioRecorderFunc )(_RecorderHandle mmHandle);
  52
  53 typedef struct
  54 {
  55         recorder_state_e prevState;
  56         recorder_state_e postState;
  57         _RecorderStateChangeReason reason;
  58         _AudioRecorderFunc  pFunc;
  59         RecorderState state;
  60 }_AudioCommandStateTable;
  61
  62 static const _AudioCommandStateTable _AUDIO_COMMAND_STATE[] =
  63 {
  64         {::RECORDER_STATE_CREATED, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, recorder_prepare, (RecorderState)-1 },
  65         {::RECORDER_STATE_READY, ::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL, recorder_start, RECORDER_STATE_STARTING },
  66         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_PAUSED, _RECORDER_STATE_REASON_NORMAL, recorder_pause, RECORDER_STATE_PAUSING },
  67         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, recorder_commit, RECORDER_STATE_STOPPING },
  68         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_CANCEL, recorder_cancel, RECORDER_STATE_STOPPING },
  69         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_SIZE_REACHED, recorder_commit, RECORDER_STATE_RECORDING },
  70         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_TIME_REACHED, recorder_commit, RECORDER_STATE_RECORDING },
  71         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL, recorder_start, RECORDER_STATE_STARTING },
  72         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, recorder_commit, RECORDER_STATE_STOPPING },
  73         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_CANCEL, recorder_cancel, RECORDER_STATE_STOPPING },
  74         {::RECORDER_STATE_READY, ::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL, recorder_unprepare, RECORDER_STATE_CLOSING },
  75 };
  76
  77 typedef struct
  78 {
  79         recorder_state_e prevState;
  80         recorder_state_e postState;
  81         _RecorderStateChangeReason reason;
  82         _RecorderEventType event;
  83         RecorderErrorReason error;
  84 }_AudioCallbackEventTable;
  85
  86 static const _AudioCallbackEventTable _AUDIO_CALLBACK_EVENT[] =
  87 {
  88         {::RECORDER_STATE_READY, ::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_RECORDING_STARTED, RECORDER_ERROR_NONE },
  89         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_PAUSED, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_PAUSED, RECORDER_ERROR_NONE },
  90         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_STOPPED, RECORDER_ERROR_NONE },
  91         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_CANCEL, _RECORDER_EVENT_CANCELED, RECORDER_ERROR_NONE },
  92         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_SIZE_REACHED, _RECORDER_EVENT_ENDOF_FILESIZE, RECORDER_ERROR_NONE },
  93         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_TIME_REACHED, _RECORDER_EVENT_ENDOF_RECTIME, RECORDER_ERROR_NONE },
  94         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_OUT_OF_STORAGE, _RECORDER_EVENT_ERROR, RECORDER_ERROR_OUT_OF_STORAGE },
  95         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_RECORDING_STARTED, RECORDER_ERROR_NONE },
  96         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_STOPPED, RECORDER_ERROR_NONE },
  97         {::RECORDER_STATE_READY, ::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL, _RECORDER_EVENT_CLOSED, RECORDER_ERROR_NONE },
  98 };
  99
 100 _AudioRecorderImpl::_AudioRecorderImpl(void)
 101         : __pRecorderRef(null)
 102         , __pAudioRecorderEvent(null)
 103         , __pAudioRecorderEventListener(null)
 104         , __pRecorderManager(null)
 105         , __isConstructed(false)
 106         , __state(RECORDER_STATE_INITIALIZED)
 107         , __recTime(-1)
 108         , __recSize(-1)
 109         , __maxTime(DEFAULT_AUDIORECORDING_TIME)
 110         , __format(AUDIORECORDING_FORMAT_AMR)
 111         , __audioCodec(CODEC_AMR_NB)
 112         , __container(MEDIA_CONTAINER_AMR)
 113         , __quality(RECORDING_QUALITY_MEDIUM)
 114         , __mute(false)
 115         , __handle(MM_INVALID_HANDLE)
 116         , __stateChangeReason(_RECORDER_STATE_REASON_NORMAL)
 117         , __pAudioStreamCoordinator(null)
 118         , __audioStreamTimeDuration(0)
 119         , __audioStreamCallback(false)
 120 {
 121
 122 }
 123
 124 _AudioRecorderImpl::~_AudioRecorderImpl(void)
 125 {
 126         if (__handle != MM_INVALID_HANDLE)
 127         {
 128                 int err = ::RECORDER_ERROR_NONE;
 129                 err = recorder_unset_state_changed_cb(__handle);
 130                 err = recorder_unset_audio_stream_cb(__handle);
 131                 err = recorder_unset_recording_limit_reached_cb(__handle);
 132                 err = recorder_unset_error_cb(__handle);
 133                 err = recorder_unset_recording_status_cb(__handle);
 134                 err = recorder_unset_interrupted_cb(__handle);
 135                 __handle = MM_INVALID_HANDLE;
 136         }
 137
 138         if (__pRecorderManager != null)
 139         {
 140                 _RecorderManager::Release(_RECORDER_DEVICE_AUDIO);
 141         }
 142
 143         SysLog(NID_MEDIA, "Destroyed");
 144 }
 145
 146 result
 147 _AudioRecorderImpl::Construct(IAudioRecorderEventListener& listener)
 148 {
 149         result r = E_SUCCESS;
 150         int err = ::RECORDER_ERROR_NONE;
 151         int streamFps = 0;
 152         _CapabilityImpl* pCapabilityImpl = null;
 153
 154         SysLog(NID_MEDIA, "Starting Audio Recorder construct.");
 155
 156         SysTryReturn(NID_MEDIA, !__isConstructed, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioRecorder is in an invalid state. A device is already constructed.");
 157
 158         // Register this object to _RecorderRef
 159         __pRecorderRef.reset(new (std::nothrow) _RecorderRef());
 160         SysTryCatch(NID_MEDIA, __pRecorderRef.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 161
 162         r = __pRecorderRef->Construct(*this, _RECORDER_DEVICE_AUDIO);
 163         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 164
 165         //Create Event
 166         __pAudioRecorderEvent.reset(new (std::nothrow) _AudioRecorderEvent());
 167         SysTryReturn(NID_MEDIA, __pAudioRecorderEvent.get() !=null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 168         r = __pAudioRecorderEvent->Construct(*this);
 169         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 170
 171         r = __pAudioRecorderEvent->AddListener(listener);
 172         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 173         __pAudioRecorderEventListener = &listener;
 174
 175         // Create audio stream coordinator
 176         __pAudioStreamCoordinator.reset(new (std::nothrow) _AudioStreamCoordinator());
 177         SysTryCatch(NID_MEDIA, __pAudioStreamCoordinator.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 178
 179         r = __pAudioStreamCoordinator->Construct();
 180         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 181
 182         pCapabilityImpl = _CapabilityImpl::GetInstance();
 183         SysTryCatch(NID_MEDIA, pCapabilityImpl != null, r= E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. Capability is not obtained.");
 184
 185         __pRecorderManager = _RecorderManager::AddInstance(_RECORDER_DEVICE_AUDIO);
 186         r = GetLastResult();
 187         SysTryCatch(NID_MEDIA, __pRecorderManager != null, , r, "[%s] audio recorder creation failed");
 188         __handle = __pRecorderManager->GetHandle();
 189
 190         // Get the audio stream fps
 191         r = pCapabilityImpl->GetValue(AUDIORECORDER_DEVICE_FPS, streamFps);
 192         SysTryCatch(NID_MEDIA, r == E_SUCCESS && streamFps > 0, , r, "[%s] Propagating. fps:%d", GetErrorMessage(r), streamFps);
 193         __audioStreamTimeDuration = (1000/streamFps); //Time duration in milisec
 194
 195         err = recorder_set_state_changed_cb(__handle, StateChangedCb, this);
 196         r = ConvertResult(err);
 197         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder set message callback failed.", GetErrorMessage(r));
 198
 199         err = recorder_set_recording_status_cb(__handle, RecordingStatusCb, this);
 200         r = ConvertResult(err);
 201         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder set recording status callback failed.", GetErrorMessage(r));
 202
 203         err = recorder_set_recording_limit_reached_cb(__handle, LimitReachedCb, this);
 204         r = ConvertResult(err);
 205         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder set limit reached callback failed.", GetErrorMessage(r));
 206
 207         err = recorder_set_error_cb(__handle, ErrorCb, this);
 208         r = ConvertResult(err);
 209         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder set limit reached callback failed.", GetErrorMessage(r));
 210
 211         err = recorder_set_interrupted_cb(__handle, InterruptedCb, this);
 212         r = ConvertResult(err);
 213         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder set limit reached callback failed.", GetErrorMessage(r));
 214
 215         // Initial configuration. This is needed for the period after Construct() and before CreateAudioFile()
 216         r = ReloadConfiguration(_RELOAD_FORMAT | _RELOAD_QUALITY | _RELOAD_MAX_TIME);
 217         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder reload configuration failed", GetErrorMessage(r));
 218
 219         SetState(RECORDER_STATE_INITIALIZED);
 220         __isConstructed = true;
 221         return r;
 222
 223 CATCH:
 224         if (__handle != MM_INVALID_HANDLE)
 225         {
 226                 err = recorder_unset_state_changed_cb(__handle);
 227                 err = recorder_unset_recording_limit_reached_cb(__handle);
 228                 err = recorder_unset_error_cb(__handle);
 229                 err = recorder_unset_recording_status_cb(__handle);
 230                 err = recorder_unset_interrupted_cb(__handle);
 231                 err = recorder_destroy(__handle);
 232                 __handle = MM_INVALID_HANDLE;
 233         }
 234
 235         if (__pAudioRecorderEventListener != null)
 236         {
 237                 __pAudioRecorderEvent->RemoveListener(*__pAudioRecorderEventListener);
 238                 __pAudioRecorderEventListener = null;
 239         }
 240
 241         __pRecorderRef.reset(null);
 242         __pAudioRecorderEvent.reset(null);
 243         __pAudioStreamCoordinator.reset(null);
 244
 245         return r;
 246 }
 247
 248 result
 249 _AudioRecorderImpl::AddAudioStreamFilter(IAudioStreamFilter& filter)
 250 {
 251         result r = E_SUCCESS;
 252
 253         r = __pAudioStreamCoordinator->AddAudioStreamFilter(filter);
 254         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 255
 256         if (__audioStreamCallback != true)
 257         {
 258                 int err = ::RECORDER_ERROR_NONE;
 259                 err = recorder_set_audio_stream_cb(__handle, AudioStreamCb, this);
 260                 r = ConvertResult(err);
 261                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] audio recorder set audio stream callback failed.", GetErrorMessage(r));
 262                 __audioStreamCallback  = true;
 263         }
 264
 265         return r;
 266 }
 267
 268 result
 269 _AudioRecorderImpl::RemoveAudioStreamFilter(IAudioStreamFilter& filter)
 270 {
 271         result r = E_SUCCESS;
 272
 273         r = __pAudioStreamCoordinator->RemoveAudioStreamFilter(filter);
 274         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 275
 276         if (__pAudioStreamCoordinator->GetFilterListCount() == 0)
 277         {
 278                 int err = ::RECORDER_ERROR_NONE;
 279                 err = recorder_unset_audio_stream_cb(__handle);
 280                 r = ConvertResult(err);
 281                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] audio recorder unset recording status callback failed.", GetErrorMessage(r));
 282                 __audioStreamCallback = false;
 283         }
 284
 285         return r;
 286 }
 287
 288 result
 289 _AudioRecorderImpl::CreateAudioFile(const Tizen::Base::String& mediaLocalPath, bool overwrite)
 290 {
 291         result r = E_SUCCESS;
 292         RecorderState state = RECORDER_STATE_ERROR;
 293         int err = ::RECORDER_ERROR_NONE;
 294         SysLog(NID_MEDIA, "Creating audio file.");
 295
 296         state = GetState();
 297         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED || state == RECORDER_STATE_CLOSED, E_INVALID_STATE,
 298                                 E_INVALID_STATE, "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.",
 299                                 state);
 300
 301         std::unique_ptr<char[]> pFileName (_StringConverter::CopyToCharArrayN(mediaLocalPath));
 302         SysTryCatch(NID_MEDIA, pFileName.get() != null, r = E_INVALID_ARG, E_INVALID_ARG, "[%s] Propagating.", GetErrorMessage(E_INVALID_ARG));
 303         SysSecureLog(NID_MEDIA, "File Path : %s\n, overwrite:%d", pFileName.get(), overwrite);
 304
 305         r = _RecorderUtil::PrepareFile(mediaLocalPath, overwrite);
 306         SysSecureTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder prepare file failed. mediaLocalPath:%s, overwirte:%d",
 307                            GetErrorMessage(r), pFileName.get(), overwrite);
 308
 309         err = recorder_set_filename(__handle, pFileName.get());
 310         r = ConvertResult(err);
 311         SysSecureTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder set attribute failed. mediaLocalPath:%s", GetErrorMessage(r), pFileName.get());
 312
 313         SetState(RECORDER_STATE_OPENED);
 314
 315         // re-configuration for new recorder handle
 316         r = ReloadConfiguration(_RELOAD_FORMAT | _RELOAD_QUALITY | _RELOAD_MAX_TIME | _RELOAD_INIT);
 317         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder reload configuration failed", GetErrorMessage(r));
 318
 319         return r;
 320
 321 CATCH:
 322         SetState(state);
 323         return r;
 324 }
 325
 326 result
 327 _AudioRecorderImpl::Close(void)
 328 {
 329         result r = E_SUCCESS;
 330         RecorderState state = RECORDER_STATE_ERROR;
 331         SysLog(NID_MEDIA, "Audio recorder close.");
 332
 333         state = GetState();
 334         SysTryReturn(
 335                 NID_MEDIA, state == RECORDER_STATE_OPENED || state == RECORDER_STATE_STOPPED
 336                 || state == RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_ERROR
 337                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.",
 338                 state);
 339
 340         r = ChangeStateTo(::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL);
 341         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 342
 343         return r;
 344 }
 345
 346 result
 347 _AudioRecorderImpl::Record(void)
 348 {
 349         result r = E_SUCCESS;
 350         RecorderState state = RECORDER_STATE_ERROR;
 351         recorder_state_e mmState = ::RECORDER_STATE_NONE;
 352         SysLog(NID_MEDIA, "Start audio recorder");
 353
 354         state = GetState();
 355         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_OPENED || state == RECORDER_STATE_PAUSED
 356                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.",
 357                                 state);
 358
 359         mmState = GetMmState();
 360         switch (mmState)
 361         {
 362         case ::RECORDER_STATE_CREATED:
 363         {
 364                 r = ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL);
 365                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder init failed.", GetErrorMessage(r));
 366                 r = ChangeStateTo(::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL);
 367                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder start failed.", GetErrorMessage(r));
 368         }
 369                 break;
 370
 371         case ::RECORDER_STATE_READY:
 372         {
 373                 r = ChangeStateTo(::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL);
 374                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder start failed.", GetErrorMessage(r));
 375         }
 376                 break;
 377
 378         case ::RECORDER_STATE_PAUSED:
 379         {
 380                 r = ChangeStateTo(::RECORDER_STATE_RECORDING, _RECORDER_STATE_REASON_NORMAL);
 381                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder resume failed.", GetErrorMessage(r));
 382         }
 383                 break;
 384
 385         default:
 386                 break;
 387         }
 388
 389         return r;
 390
 391 CATCH:
 392         switch (mmState)
 393         {
 394         case ::RECORDER_STATE_READY:
 395         {
 396                 ChangeStateTo(::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL);
 397         }
 398                 break;
 399
 400         case ::RECORDER_STATE_PAUSED:
 401         {
 402                 ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL);
 403                 ChangeStateTo(::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL);
 404         }
 405                 break;
 406
 407         default:
 408                 break;
 409         }
 410
 411         return r;
 412 }
 413
 414 result
 415 _AudioRecorderImpl::Stop(void)
 416 {
 417         result r = E_SUCCESS;
 418         RecorderState state = RECORDER_STATE_ERROR;
 419         SysLog(NID_MEDIA, "Stop audio recorder");
 420
 421         state = GetState();
 422         SysTryReturn(
 423                 NID_MEDIA, state == RECORDER_STATE_RECORDING || state == RECORDER_STATE_PAUSING || state == RECORDER_STATE_PAUSED
 424                 || state == RECORDER_STATE_STARTING
 425                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.",
 426                 state);
 427
 428         r = ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL);
 429         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] audio recorder record stop failed.", GetErrorMessage(r));
 430
 431         return r;
 432 }
 433
 434 result
 435 _AudioRecorderImpl::Pause(void)
 436 {
 437         result r = E_SUCCESS;
 438         RecorderState state = RECORDER_STATE_ERROR;
 439         SysLog(NID_MEDIA, "Pause audio recorder");
 440
 441         state = GetState();
 442         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_RECORDING, E_INVALID_STATE, E_INVALID_STATE,
 443                                 "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.",
 444                                 state);
 445
 446         r = ChangeStateTo(::RECORDER_STATE_PAUSED, _RECORDER_STATE_REASON_NORMAL);
 447         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] audio recorder pause failed.", GetErrorMessage(r));
 448
 449         return r;
 450 }
 451
 452 result
 453 _AudioRecorderImpl::Cancel(void)
 454 {
 455         result r = E_SUCCESS;
 456         RecorderState state = RECORDER_STATE_ERROR;
 457         SysLog(NID_MEDIA, "Cancle audio recorder");
 458
 459         state = GetState();
 460         SysTryReturn(
 461                 NID_MEDIA, state == RECORDER_STATE_RECORDING || state == RECORDER_STATE_PAUSING || state == RECORDER_STATE_PAUSED
 462                 || state == RECORDER_STATE_STARTING, E_INVALID_STATE, E_INVALID_STATE,
 463                 "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.", state);
 464
 465         r = ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_CANCEL);
 466         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] audio recorder cancel failed.", GetErrorMessage(r));
 467
 468         return r;
 469 }
 470
 471 RecorderState
 472 _AudioRecorderImpl::GetState(void) const
 473 {
 474         return __state;
 475 }
 476
 477 long
 478 _AudioRecorderImpl::GetRecordingTime(void) const
 479 {
 480         return __recTime;
 481 }
 482
 483 long
 484 _AudioRecorderImpl::GetRecordingSize(void) const
 485 {
 486         return __recSize;
 487 }
 488
 489 result
 490 _AudioRecorderImpl::SetMaxRecordingTime(long msTime)
 491 {
 492         result r = E_SUCCESS;
 493         RecorderState state = RECORDER_STATE_ERROR;
 494         int err = ::RECORDER_ERROR_NONE;
 495         int secTime = MEDIA_INVALID_VALUE;
 496         SysLog(NID_MEDIA, "Enter. msTime:%d", msTime);
 497
 498         state = GetState();
 499         SysTryReturn(
 500                 NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 501                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
 502                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.",
 503                 state);
 504
 505         SysTryReturn(NID_MEDIA, msTime > 0, E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] msTime:%d must be greater than 0.",
 506                                 msTime);
 507
 508         // msec max time is not possible to set
 509         secTime = msTime > 1000 ? ((msTime+500)  / 1000) : 1;
 510         err = recorder_attr_set_time_limit(__handle, secTime);
 511         r = ConvertResult(err);
 512         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder set attribute failed. msTime:%d", GetErrorMessage(r), msTime);
 513
 514         // For reload and Get the exact value
 515         __maxTime = msTime;
 516
 517         return r;
 518
 519 CATCH:
 520         return r;
 521 }
 522
 523 long
 524 _AudioRecorderImpl::GetMaxRecordingTime(void) const
 525 {
 526         return __maxTime;
 527 }
 528
 529 result
 530 _AudioRecorderImpl::SetFormat(AudioRecordingFormat format)
 531 {
 532         result r = E_SUCCESS;
 533         RecorderState state = RECORDER_STATE_ERROR;
 534         CodecType codec = CODEC_NONE;
 535         MediaContainerType container = MEDIA_CONTAINER_NONE;
 536         int err = ::RECORDER_ERROR_NONE;
 537         recorder_audio_codec_e attrCodec = ::RECORDER_AUDIO_CODEC_AMR;
 538         recorder_file_format_e attrFormat = ::RECORDER_FILE_FORMAT_AMR;
 539         SysLog(NID_MEDIA, "Enter. format:%d", format);
 540
 541         state = GetState();
 542         SysTryReturn(
 543                 NID_MEDIA, state == RECORDER_STATE_INITIALIZED || state == RECORDER_STATE_OPENED || state ==
 544                 RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
 545                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.",
 546                 state);
 547
 548         SysTryReturn(NID_MEDIA, (format >= AUDIORECORDING_FORMAT_DEFAULT && format <= AUDIORECORDING_FORMAT_WAVE)
 549                            , E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] The format(%d) was wrong.", format);
 550
 551         GetMediaType(format, codec, container);
 552         SysLog(NID_MEDIA, "format:%d, codec:0x%x, container:0x%x", format, codec, container);
 553
 554         r = _RecorderUtil::GetMmAudioCodec(codec, attrCodec);
 555         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audio codec:0x%x", GetErrorMessage(r), codec);
 556
 557         err = recorder_set_audio_encoder(__handle, attrCodec);
 558         r = ConvertResult(err);
 559         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Audio codec set  failed. codec:0x%x", GetErrorMessage(r), codec);
 560
 561         r = _RecorderUtil::GetMmFileFormat(container, attrFormat);
 562         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. container:0x%x", GetErrorMessage(r), container);
 563
 564         err = recorder_set_file_format(__handle, attrFormat);
 565         r = ConvertResult(err);
 566         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] setting file format failed for container:0x%x", GetErrorMessage(r), container);
 567
 568         __format = format;
 569         __audioCodec = codec;
 570         __container = container;
 571
 572         // Call the dependency function.
 573         r = ReloadConfiguration(_RELOAD_QUALITY);
 574         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder reload configuration failed. format:%d", GetErrorMessage(
 575                                    r), format);
 576
 577         return r;
 578
 579 CATCH:
 580         return r;
 581 }
 582
 583 AudioRecordingFormat
 584 _AudioRecorderImpl::GetFormat(void) const
 585 {
 586         return __format;
 587 }
 588
 589 result
 590 _AudioRecorderImpl::SetFormat(CodecType audioCodec, MediaContainerType container)
 591 {
 592         result r = E_SUCCESS;
 593         RecorderState state = RECORDER_STATE_ERROR;
 594         bool supported = false;
 595         int err = ::RECORDER_ERROR_NONE;
 596         recorder_audio_codec_e attrCodec = ::RECORDER_AUDIO_CODEC_AMR;
 597         recorder_file_format_e attrFormat = ::RECORDER_FILE_FORMAT_AMR;
 598         SysLog(NID_MEDIA, "Enter. audioCodec:0x%x, container:0x%x", audioCodec, container);
 599
 600         state = GetState();
 601         SysTryReturn(
 602                 NID_MEDIA, state == RECORDER_STATE_INITIALIZED || state == RECORDER_STATE_OPENED || state ==
 603                 RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
 604                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.",
 605                 state);
 606
 607         std::unique_ptr <IListT<CodecType>, _ListPtrUtil::Remover> pAudioCodecListT (GetSupportedCodecListN(), _ListPtrUtil::remover);
 608         SysTryReturn(NID_MEDIA, pAudioCodecListT.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
 609         SysTryReturn(NID_MEDIA, pAudioCodecListT->Contains(audioCodec), E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC,
 610                 "[E_UNSUPPORTED_CODEC]This AudioCodec(%d) is not supported in the device.\n", audioCodec);
 611
 612         std::unique_ptr <IListT<MediaContainerType>, _ListPtrUtil::Remover> pContainerCodecListT (GetSupportedContainerListN(), _ListPtrUtil::remover);
 613         SysTryReturn(NID_MEDIA, pContainerCodecListT.get() != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
 614         SysTryReturn(NID_MEDIA, pContainerCodecListT->Contains(container), E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT,
 615                 "[E_UNSUPPORTED_FORMAT]This Container(%d) is not supported in the device.\n", container);
 616
 617         supported = _RecorderUtil::CheckFormat(audioCodec, CODEC_NONE, container);
 618         SysTryCatch(NID_MEDIA, supported, r = E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT,
 619                            "[E_UNSUPPORTED_FORMAT] audio recorder check foramt failed. audioCodec:0x%x, videoCodec:0x%x, container:0x%x",
 620                            audioCodec, CODEC_NONE, container);
 621
 622         r = _RecorderUtil::GetMmAudioCodec(audioCodec, attrCodec);
 623         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audio codec:0x%x", GetErrorMessage(r), audioCodec);
 624
 625         err = recorder_set_audio_encoder(__handle, attrCodec);
 626         r = ConvertResult(err);
 627         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Audio codec set  failed. codec:0x%x", GetErrorMessage(r), audioCodec);
 628
 629         r = _RecorderUtil::GetMmFileFormat(container, attrFormat);
 630         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. container:0x%x", GetErrorMessage(r), container);
 631
 632         err = recorder_set_file_format(__handle, attrFormat);
 633         r = ConvertResult(err);
 634         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] setting file format failed for container:0x%x", GetErrorMessage(r), container);
 635
 636         __audioCodec = audioCodec;
 637         __container = container;
 638
 639         // Call the dependency function.
 640         r = ReloadConfiguration(_RELOAD_QUALITY);
 641         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder reload configuration failed. audioCodec:0x%x, container:0x%x",
 642                            GetErrorMessage(r), audioCodec, container);
 643
 644 CATCH:
 645         return r;
 646 }
 647
 648 void
 649 _AudioRecorderImpl::GetFormat(CodecType& audioCodec, MediaContainerType& container) const
 650 {
 651         audioCodec = __audioCodec;
 652         container = __container;
 653 }
 654
 655 Tizen::Base::Collection::ArrayListT <CodecType>*
 656 _AudioRecorderImpl::GetSupportedCodecListN(void) const
 657 {
 658         result r = E_SUCCESS;
 659         _ResultType itemType = _RESULT_INTEGER_LIST;
 660         SysLog(NID_MEDIA, "Get supported codec list of audio recorder");
 661
 662         std::unique_ptr <IList, _ListPtrUtil::Remover> pIntegerList (_RecorderCapability::GetListN(_AROP_AUDIO_ENCODER, itemType), _ListPtrUtil::remover);
 663         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list is wrong.");
 664         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list is empty.");
 665
 666         std::unique_ptr <ArrayListT<CodecType>, _ListPtrUtil::Remover> pAudioCodecList (new (std::nothrow) ArrayListT<CodecType>(), _ListPtrUtil::remover);
 667         SysTryReturn(NID_MEDIA, pAudioCodecList.get() != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 668
 669         r = pAudioCodecList->Construct();
 670         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 671
 672         for (int i = 0; i < pIntegerList->GetCount(); i++)
 673         {
 674                 Object* pObj = null;
 675                 Integer* pInteger = null;
 676                 pObj = pIntegerList->GetAt(i);
 677                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object(%d) instance is not available.", i);
 678
 679                 pInteger = dynamic_cast<Integer*>(pObj);
 680                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's format is invalid.", i);
 681
 682                 r = pAudioCodecList->Add((CodecType)pInteger->ToInt());
 683                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 684                 SysLog(NID_MEDIA, "Pixel format : %d was added.", pInteger->ToInt());
 685         }
 686
 687         return pAudioCodecList.release();
 688
 689 CATCH:
 690         return null;
 691 }
 692
 693 Tizen::Base::Collection::ArrayListT <MediaContainerType>*
 694 _AudioRecorderImpl::GetSupportedContainerListN(void) const
 695 {
 696         result r = E_SUCCESS;
 697         _ResultType itemType = _RESULT_INTEGER_LIST;
 698         SysLog(NID_MEDIA, "get supported container list of audio recorder");
 699
 700         std::unique_ptr <IList, _ListPtrUtil::Remover> pIntegerList (_RecorderCapability::GetListN(_AROP_FILE_FORMAT, itemType), _ListPtrUtil::remover);
 701         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list is wrong.");
 702         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list is empty.");
 703
 704         std::unique_ptr <ArrayListT<MediaContainerType>, _ListPtrUtil::Remover> pContainerList (new (std::nothrow) ArrayListT<MediaContainerType>(), _ListPtrUtil::remover);
 705         SysTryReturn(NID_MEDIA, pContainerList.get() != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed. The object is not created.");
 706
 707         r = pContainerList->Construct();
 708         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 709
 710         for (int i = 0; i < pIntegerList->GetCount(); i++)
 711         {
 712                 Object* pObj = null;
 713                 Integer* pInteger = null;
 714                 pObj = pIntegerList->GetAt(i);
 715                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object(%d) instance is not available.", i);
 716
 717                 pInteger = dynamic_cast<Integer*>(pObj);
 718                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's format is invalid.", i);
 719
 720                 r = pContainerList->Add((MediaContainerType)pInteger->ToInt());
 721                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 722                 SysLog(NID_MEDIA, "Pixel format : %d was added.", pInteger->ToInt());
 723         }
 724
 725         return pContainerList.release();
 726
 727 CATCH:
 728         return null;
 729 }
 730
 731 result
 732 _AudioRecorderImpl::SetQuality(RecordingQuality quality)
 733 {
 734         result r = E_SUCCESS;
 735         RecorderState state = RECORDER_STATE_ERROR;
 736         CodecType audioCodec = CODEC_NONE;
 737         MediaContainerType container = MEDIA_CONTAINER_NONE;
 738         int err = ::RECORDER_ERROR_NONE;
 739         int attrSamplerate = 0;
 740         int attrChannel = 0;
 741         int attrBitrate = 0;
 742         SysLog(NID_MEDIA, "Enter. quality:%d", quality);
 743
 744         state = GetState();
 745         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 746                                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
 747                            , E_INVALID_STATE, r, "[E_INVALID_STATE] AudioRecorder is in an invalid state. AudioRecorder state is %d.", state);
 748
 749         SysTryReturn(NID_MEDIA, (quality >= RECORDING_QUALITY_LOW && quality <= RECORDING_QUALITY_HIGH)
 750                            , E_INVALID_ARG, r, "[E_INVALID_ARG] Invalid argument(quality) is used. quality(%d) is wrong.", quality);
 751
 752         GetFormat(audioCodec, container);
 753
 754         r = _RecorderUtil::GetMmAudioQuality(audioCodec, quality, attrSamplerate, attrChannel, attrBitrate);
 755         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audiocodec:0x%x, quality:%d", GetErrorMessage(r), container, quality);
 756
 757         err = recorder_attr_set_audio_samplerate(__handle, attrSamplerate);
 758         r = ConvertResult(err);
 759         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Sampling-rate set  failed. attr:%d", GetErrorMessage(r), attrSamplerate);
 760
 761         err = recorder_attr_set_audio_channel(__handle, attrChannel);
 762         r = ConvertResult(err);
 763         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Channel set  failed. attr:%d", GetErrorMessage(r), attrChannel);
 764
 765         err = recorder_attr_set_audio_encoder_bitrate(__handle, attrBitrate);
 766         r = ConvertResult(err);
 767         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Bitrate set  failed. attr:%d", GetErrorMessage(r), attrBitrate);
 768
 769         // For keeping the quality of each format. SetQuality will be called again after SetFormat() is changing the format.
 770         __quality = quality;
 771
 772 CATCH:
 773         return r;
 774 }
 775
 776 RecordingQuality
 777 _AudioRecorderImpl::GetQuality(void) const
 778 {
 779         return __quality;
 780 }
 781
 782 result
 783 _AudioRecorderImpl::SetMute(bool mute)
 784 {
 785         result r = E_SUCCESS;
 786         RecorderState state = RECORDER_STATE_ERROR;
 787         int err = ::RECORDER_ERROR_NONE;
 788         SysLog(NID_MEDIA, "Enter. mute:%d", mute);
 789
 790         state = GetState();
 791         SysTryReturn(NID_MEDIA, state == RECORDER_STATE_INITIALIZED
 792                                 || state == RECORDER_STATE_OPENED || state == RECORDER_STATE_ENDOF_FILE || state == RECORDER_STATE_CLOSED
 793                                 || state == RECORDER_STATE_STOPPED || state == RECORDER_STATE_PAUSED || state == RECORDER_STATE_RECORDING
 794                            , E_INVALID_STATE, r, "[E_INVALID_STATE] state:%d, AudioRecorder is in an invalid state. AudioRecorder state is %d.", state);
 795
 796         err = recorder_attr_set_mute(__handle, mute);
 797         r = ConvertResult(err);
 798         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] audio recorder set mute failed", GetErrorMessage(r));
 799
 800         __mute = mute;
 801         return r;
 802
 803 CATCH:
 804         return r;
 805 }
 806
 807 bool
 808 _AudioRecorderImpl::IsMuted(void) const
 809 {
 810         return __mute;
 811 }
 812
 813 result
 814 _AudioRecorderImpl::ConvertResult(int err) const
 815 {
 816         result r = E_SYSTEM;
 817         if (err != ::RECORDER_ERROR_NONE)
 818         {
 819                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
 820         }
 821
 822         // Global error
 823         if (err == ::RECORDER_ERROR_NONE)
 824         {
 825                 r = E_SUCCESS;
 826         }
 827         else if (err == ::RECORDER_ERROR_INVALID_PARAMETER)
 828         {
 829                 r = E_INVALID_ARG;
 830         }
 831         else if (err == ::RECORDER_ERROR_INVALID_STATE)
 832         {
 833                 r = E_INVALID_STATE;
 834         }
 835         else if (err == ::RECORDER_ERROR_OUT_OF_MEMORY)
 836         {
 837                 r = E_OUT_OF_MEMORY;
 838         }
 839         else if (err == ::RECORDER_ERROR_DEVICE)
 840         {
 841                 r = E_DEVICE_FAILED;
 842         }
 843         else if (err == ::RECORDER_ERROR_INVALID_OPERATION
 844                 || err == ::RECORDER_ERROR_SECURITY_RESTRICTED)
 845         {
 846                 r = E_SYSTEM;
 847         }
 848         else if (err == ::RECORDER_ERROR_SOUND_POLICY)
 849         {
 850                 r = E_DEVICE_BUSY;
 851         }
 852         else
 853         {
 854                 r = E_UNKNOWN;
 855         }
 856
 857         return r;
 858 }
 859
 860 void
 861 _AudioRecorderImpl::SetState(RecorderState state)
 862 {
 863         __state = state;
 864 }
 865
 866 void
 867 _AudioRecorderImpl::SetRecordingTime(long recTime)
 868 {
 869         __recTime = recTime;
 870 }
 871
 872 void
 873 _AudioRecorderImpl::SetRecordingSize(long recSize)
 874 {
 875         __recSize = recSize;
 876 }
 877
 878 void
 879 _AudioRecorderImpl::GetMediaType(AudioRecordingFormat format, CodecType& codec, MediaContainerType& container) const
 880 {
 881         switch (format)
 882         {
 883         case AUDIORECORDING_FORMAT_DEFAULT:
 884                 //fall through
 885         case AUDIORECORDING_FORMAT_AMR:
 886         {
 887                 codec = CODEC_AMR_NB;
 888                 container = MEDIA_CONTAINER_AMR;
 889         }
 890                 break;
 891
 892         case AUDIORECORDING_FORMAT_WAVE:
 893         {
 894                 codec = CODEC_LPCM;
 895                 container = MEDIA_CONTAINER_WAV;
 896         }
 897                 break;
 898
 899         default:
 900         {
 901                 codec = CODEC_NONE;
 902                 container = MEDIA_CONTAINER_NONE;
 903         }
 904                 break;
 905         }
 906 }
 907
 908 void
 909 _AudioRecorderImpl::GetMediaType(MediaContainerType container, AudioRecordingFormat& format) const
 910 {
 911         switch (container)
 912         {
 913         case MEDIA_CONTAINER_AMR:
 914         {
 915                 format = AUDIORECORDING_FORMAT_AMR;
 916         }
 917                 break;
 918
 919         case MEDIA_CONTAINER_WAV:
 920         {
 921                 format = AUDIORECORDING_FORMAT_WAVE;
 922         }
 923                 break;
 924
 925         default:
 926         {
 927                 format = AUDIORECORDING_FORMAT_DEFAULT;
 928         }
 929                 break;
 930         }
 931 }
 932
 933 result
 934 _AudioRecorderImpl::ReloadConfiguration(int reload)
 935 {
 936         result r = E_SUCCESS;
 937         int err = ::RECORDER_ERROR_NONE;
 938
 939         SysLog(NID_MEDIA, "Enter. reload:0x%x", reload);
 940
 941         if (reload & _RELOAD_FORMAT)
 942         {
 943                 recorder_audio_codec_e attrCodec = ::RECORDER_AUDIO_CODEC_AMR;
 944                 r = _RecorderUtil::GetMmAudioCodec(__audioCodec, attrCodec);
 945                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audio codec:0x%x", GetErrorMessage(r), __audioCodec);
 946
 947                 err = recorder_set_audio_encoder(__handle, attrCodec);
 948                 r = ConvertResult(err);
 949                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Audio codec set  failed. codec:0x%x", GetErrorMessage(r), __audioCodec);
 950
 951                 recorder_file_format_e attrFormat = ::RECORDER_FILE_FORMAT_AMR;
 952                 r = _RecorderUtil::GetMmFileFormat(__container, attrFormat);
 953                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. container:0x%x", GetErrorMessage(r), __container);
 954
 955                 err = recorder_set_file_format(__handle, attrFormat);
 956                 r = ConvertResult(err);
 957                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] setting file format failed for container:0x%x", GetErrorMessage(r), __container);
 958         }
 959         if (reload & _RELOAD_QUALITY)
 960         {
 961                 int attrSamplerate = 0;
 962                 int attrChannel = 0;
 963                 int attrBitrate = 0;
 964                 r = _RecorderUtil::GetMmAudioQuality(__audioCodec, __quality, attrSamplerate, attrChannel, attrBitrate);
 965                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audiocodec:0x%x, quality:%d", GetErrorMessage(r), __container, __quality);
 966
 967                 err = recorder_attr_set_audio_samplerate(__handle, attrSamplerate);
 968                 r = ConvertResult(err);
 969                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Sampling-rate set     failed. attr:%d", GetErrorMessage(r), attrSamplerate);
 970
 971                 err = recorder_attr_set_audio_channel(__handle, attrChannel);
 972                 r = ConvertResult(err);
 973                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Channel set  failed. attr:%d", GetErrorMessage(r), attrChannel);
 974
 975                 err = recorder_attr_set_audio_encoder_bitrate(__handle, attrBitrate);
 976                 r = ConvertResult(err);
 977                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Bitrate set  failed. attr:%d", GetErrorMessage(r), attrBitrate);
 978         }
 979         if (reload & _RELOAD_MAX_TIME)
 980         {
 981                 int secTime = 0;
 982                 secTime = __maxTime > 1000 ? ((__maxTime+500)  / 1000) : 1;
 983                 err = recorder_attr_set_time_limit(__handle, secTime);
 984                 r = ConvertResult(err);
 985                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
 986         }
 987         if (reload & _RELOAD_INIT)
 988         {
 989                 __recTime = 0;
 990                 __recSize = 0;
 991         }
 992
 993         return r;
 994
 995 CATCH:
 996         return r;
 997 }
 998
 999
1000 recorder_state_e
1001 _AudioRecorderImpl::GetMmState(void) const
1002 {
1003         result r = E_SUCCESS;
1004         int err = ::RECORDER_ERROR_NONE;
1005         recorder_state_e mmState = ::RECORDER_STATE_NONE;
1006
1007         err = recorder_get_state(__handle, &mmState);
1008         r = ConvertResult(err);
1009         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1010
1011         return mmState;
1012
1013 CATCH:
1014         return ::RECORDER_STATE_NONE;
1015 }
1016
1017 result
1018 _AudioRecorderImpl::ChangeStateTo(recorder_state_e mmDestState, _RecorderStateChangeReason reason)
1019 {
1020         result r = E_SUCCESS;
1021         int tableTotalCount = 0;
1022         int i = 0;
1023         int err = MM_SUCCESS;
1024         recorder_state_e preState = ::RECORDER_STATE_NONE;
1025         recorder_state_e postState = ::RECORDER_STATE_NONE;
1026
1027         preState = GetMmState();
1028         tableTotalCount = sizeof(_AUDIO_COMMAND_STATE) / sizeof(_AUDIO_COMMAND_STATE[0]);
1029         SysLog(NID_MEDIA, " PreState:%d, mmDestState:%d, tableTotalCount:%d", preState, mmDestState, tableTotalCount);
1030
1031         for (i = 0; i < tableTotalCount; i++)
1032         {
1033                 if (preState == _AUDIO_COMMAND_STATE[i].prevState && mmDestState == _AUDIO_COMMAND_STATE[i].postState && reason ==
1034                         _AUDIO_COMMAND_STATE[i].reason)
1035                 {
1036                         if (_AUDIO_COMMAND_STATE[i].pFunc != null)
1037                         {
1038                                 SysLog(NID_MEDIA,
1039                                                         "Exist the matching state field. loop i:%d, current state:%d, mmDestState:%d, reason:%d", i,
1040                                                         preState, mmDestState, reason);
1041                                 err = _AUDIO_COMMAND_STATE[i].pFunc(__handle);
1042                                 r = ConvertResult(err);
1043                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1044
1045                                 // Check whether the retuned states are destinationed states.
1046                                 postState = GetMmState();
1047                                 SysTryCatch(NID_MEDIA, mmDestState == postState, r = E_INVALID_STATE, E_INVALID_STATE,
1048                                                    "[E_INVALID_STATE] recorder_state_e of C-API is in an invalid state. result postState:%d is different from the desired state:%d", postState,
1049                                                    mmDestState);
1050                                 SysLog(NID_MEDIA, "[E_SUCCESS] Found. result postState:%d, param mmDestState:%d", postState, mmDestState);
1051
1052                                 __stateChangeReason = reason;           //for distinguish between stop and cancel and end reach.
1053                         }
1054
1055                         if (_AUDIO_COMMAND_STATE[i].state >= RECORDER_STATE_INITIALIZED && _AUDIO_COMMAND_STATE[i].state <= RECORDER_STATE_ERROR)
1056                         {
1057                                 SysLog(NID_MEDIA, "State set to %d", _AUDIO_COMMAND_STATE[i].state);
1058                                 SetState(_AUDIO_COMMAND_STATE[i].state);
1059                         }
1060                         break;
1061                 }
1062
1063         }
1064         SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
1065         return r;
1066
1067 CATCH:
1068         SysLog(NID_MEDIA, "[%s] Real preState:%d, param mmDestState:%d", GetErrorMessage(r), preState, mmDestState);
1069         return r;
1070 }
1071
1072 _RecorderStateChangeReason
1073 _AudioRecorderImpl::GetStateChangeReason(void) const
1074 {
1075         return __stateChangeReason;
1076 }
1077
1078 _AudioRecorderEvent*
1079 _AudioRecorderImpl::GetEvent(void) const
1080 {
1081         return __pAudioRecorderEvent.get();
1082 }
1083
1084 void
1085 _AudioRecorderImpl::StateChangedCb(recorder_state_e previous, recorder_state_e current, bool byPolicy, void* pUserData)
1086 {
1087         result r = E_SUCCESS;
1088         _AudioRecorderImpl* pImpl = static_cast<_AudioRecorderImpl*>( pUserData);
1089         int tableTotalCount = 0;
1090         int i = 0;
1091         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _AudioRecorderImpl instance is not available. pImpl is null.");
1092         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1093         SysLog(NID_MEDIA, "State previous:%d, current:%d, byPolicy:%d", previous, current, byPolicy);
1094
1095         tableTotalCount = sizeof(_AUDIO_CALLBACK_EVENT) / sizeof(_AUDIO_CALLBACK_EVENT[0]);
1096
1097         for (i = 0; i < tableTotalCount; i++)
1098         {
1099                 if (previous == _AUDIO_CALLBACK_EVENT[i].prevState && current == _AUDIO_CALLBACK_EVENT[i].postState && pImpl->GetStateChangeReason() == _AUDIO_CALLBACK_EVENT[i].reason)
1100                 {
1101                         r = pImpl->GetEvent()->SendEvent(_AUDIO_CALLBACK_EVENT[i].event, _AUDIO_CALLBACK_EVENT[i].error, E_SUCCESS);
1102                         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1103                         break;
1104                 }
1105         }
1106         SysTryReturnVoidResult(NID_MEDIA, i != tableTotalCount, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Not found. ");
1107 }
1108
1109 void
1110 _AudioRecorderImpl::RecordingStatusCb(unsigned long long elapsedTime, unsigned long long fileSize, void *pUserData)
1111 {
1112         _AudioRecorderImpl* pImpl = static_cast<_AudioRecorderImpl*>(pUserData);
1113         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _AudioRecorderImpl instance is not available. pImpl is null.");
1114         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1115
1116         SysLog(NID_MEDIA, " FileSize:%llu,elapsedTime:%llu",fileSize,elapsedTime);
1117
1118         pImpl->SetRecordingTime((long)elapsedTime);
1119         pImpl->SetRecordingSize((long)fileSize);
1120 }
1121
1122 void
1123 _AudioRecorderImpl::AudioStreamCb(void* pStream, int size, audio_sample_type_e format, int channel, unsigned int timeStamp, void *pUserData)
1124 {
1125         _AudioRecorderImpl* pImpl = static_cast<_AudioRecorderImpl*>(pUserData);
1126         int samplingRate =0;
1127         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _AudioRecorderImpl instance is not available. pImpl is null.");
1128         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1129         SysTryReturnVoidResult(NID_MEDIA, pStream != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _AudioRecorderImpl instance is not available. Stream data is null.");
1130
1131         if (pImpl->__audioStreamCallback == true)
1132         {
1133                 samplingRate = _RecorderUtil::CalculateSampleRate(size, channel, pImpl->__audioStreamTimeDuration, _RecorderUtil::GetOspSampleType(format));
1134                 (pImpl->__pAudioStreamCoordinator)->ProcessAudioStreamData((byte*)pStream, size, samplingRate, _RecorderUtil::GetOspChannelType(channel), _RecorderUtil::GetOspSampleType(format));
1135         }
1136 }
1137
1138 void
1139 _AudioRecorderImpl::LimitReachedCb(recorder_recording_limit_type_e type, void *pUserData)
1140 {
1141         result r = E_SUCCESS;
1142         _AudioRecorderImpl* pImpl = static_cast<_AudioRecorderImpl*>(pUserData);
1143         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _AudioRecorderImpl instance is not available. pImpl is null.");
1144         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1145
1146         SysLog(NID_MEDIA, "Type:%d", type);
1147
1148         switch (type)
1149         {
1150         case ::RECORDER_RECORDING_LIMIT_TIME:
1151         {
1152                 r = pImpl->ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_TIME_REACHED);
1153                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1154         }
1155                 break;
1156
1157         case ::RECORDER_RECORDING_LIMIT_SIZE:
1158         {
1159                 r = pImpl->ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_END_SIZE_REACHED);
1160                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1161         }
1162                 break;
1163
1164         case ::RECORDER_RECORDING_LIMIT_FREE_SPACE:
1165         {
1166                 r = pImpl->ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_OUT_OF_STORAGE);
1167                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1168
1169                 r = pImpl->GetEvent()->SendEvent(_RECORDER_EVENT_ERROR, RECORDER_ERROR_OUT_OF_STORAGE, E_STORAGE_FULL);
1170                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1171         }
1172                 break;
1173
1174         default:
1175                 break;
1176         }
1177
1178 CATCH:
1179         return;
1180 }
1181
1182 void
1183 _AudioRecorderImpl::ErrorCb(recorder_error_e error, recorder_state_e state, void *pUserData)
1184 {
1185         result r = E_SUCCESS;
1186         _AudioRecorderImpl* pImpl = static_cast<_AudioRecorderImpl*>(pUserData);
1187         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _AudioRecorderImpl instance is not available. pImpl is null.");
1188         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1189
1190         SysLog(NID_MEDIA, "Error:%d, state:%d", error, state);
1191
1192         r = pImpl->GetEvent()->SendEvent(_RECORDER_EVENT_ERROR, RECORDER_ERROR_DEVICE_FAILED, E_SUCCESS);
1193         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1194
1195         return;
1196 }
1197
1198 void
1199 _AudioRecorderImpl::InterruptedCb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *pUserData)
1200 {
1201         _AudioRecorderImpl* pImpl = static_cast<_AudioRecorderImpl*>(pUserData);
1202         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] pImpl _AudioRecorderImpl is not available. pImpl is null.");
1203         SysTryReturnVoidResult(NID_MEDIA, _CamRef::IsAlive(*pImpl), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
1204
1205         SysLog(NID_MEDIA, "Policy:%d, previous:%d, current:%d", policy, previous, current);
1206 }
1207
1208 _AudioRecorderImpl*
1209 _AudioRecorderImpl::GetInstance(AudioRecorder *pAudioRecorder)
1210 {
1211         if ( pAudioRecorder !=null )
1212         {
1213                 return pAudioRecorder->__pImpl;
1214         }
1215         return null;
1216 }
1217
1218 const _AudioRecorderImpl*
1219 _AudioRecorderImpl::GetInstance(const AudioRecorder *pAudioRecorder)
1220 {
1221         if ( pAudioRecorder !=null )
1222         {
1223                 return pAudioRecorder->__pImpl;
1224         }
1225         return null;
1226 }
1227
1228 }}   // Tizen::Media