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