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