2 // Open Service Platform
3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
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
9 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 * @file FMedia_AudioRecorderImpl.cpp
20 * @brief This file contains the implementation of the _AudioRecorder_Impl class.
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"
39 using namespace Tizen::Base;
40 using namespace Tizen::Base::Collection;
41 using namespace Tizen::Io;
43 namespace Tizen { namespace Media
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;
50 typedef int (*_AudioRecorderFunc )(_RecorderHandle mmHandle);
54 recorder_state_e prevState;
55 recorder_state_e postState;
56 _RecorderStateChangeReason reason;
57 _AudioRecorderFunc pFunc;
59 }_AudioCommandStateTable;
61 static const _AudioCommandStateTable _AUDIO_COMMAND_STATE[] =
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 },
78 recorder_state_e prevState;
79 recorder_state_e postState;
80 _RecorderStateChangeReason reason;
81 _RecorderEventType event;
82 RecorderErrorReason error;
83 }_AudioCallbackEventTable;
85 static const _AudioCallbackEventTable _AUDIO_CALLBACK_EVENT[] =
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 },
99 bool _AudioRecorderImpl::__isUsed = false;
101 _AudioRecorderImpl::_AudioRecorderImpl(void)
102 : __pAudioRecorderEvent(null)
103 , __pAudioRecorderEventListener(null)
104 , __pRecorderManager(null)
105 , __isConstructed(false)
106 , __state(RECORDER_STATE_INITIALIZED)
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)
115 , __handle(MM_INVALID_HANDLE)
116 , __stateChangeReason(_RECORDER_STATE_REASON_NORMAL)
117 , __pAudioStreamCoordinator(null)
118 , __audioStreamTimeDuration(0)
119 , __audioStreamCallback(false)
124 _AudioRecorderImpl::~_AudioRecorderImpl(void)
126 if (__handle != MM_INVALID_HANDLE)
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;
138 if (__pRecorderManager != null)
140 _RecorderManager::Release(_RECORDER_DEVICE_AUDIO);
148 SysLog(NID_MEDIA, "Destroyed");
152 _AudioRecorderImpl::Construct(IAudioRecorderEventListener& listener)
154 result r = E_SUCCESS;
155 int err = ::RECORDER_ERROR_NONE;
157 _CapabilityImpl* pCapabilityImpl = null;
159 SysLog(NID_MEDIA, "Starting Audio Recorder construct.");
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.");
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));
171 r = __pAudioRecorderEvent->AddListener(listener);
172 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
173 __pAudioRecorderEventListener = &listener;
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.");
179 r = __pAudioStreamCoordinator->Construct();
180 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
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.");
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));
193 __audioStreamTimeDuration = (1000/streamFps); //Time duration in milisec
196 __pRecorderManager = _RecorderManager::AddInstance(_RECORDER_DEVICE_AUDIO);
198 SysTryCatch(NID_MEDIA, __pRecorderManager != null, , r, "[%s] audio recorder creation failed");
200 __handle = __pRecorderManager->GetHandle();
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));
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));
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));
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));
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));
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));
226 SetState(RECORDER_STATE_INITIALIZED);
227 __isConstructed = true;
232 if (__handle != MM_INVALID_HANDLE)
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;
243 if (__pAudioRecorderEventListener != null)
245 __pAudioRecorderEvent->RemoveListener(*__pAudioRecorderEventListener);
246 __pAudioRecorderEventListener = null;
249 __pAudioRecorderEvent.reset(null);
255 _AudioRecorderImpl::AddAudioStreamFilter(IAudioStreamFilter& filter)
257 result r = E_SUCCESS;
259 r = __pAudioStreamCoordinator->AddAudioStreamFilter(filter);
260 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
262 if (__audioStreamCallback != true)
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;
275 _AudioRecorderImpl::RemoveAudioStreamFilter(IAudioStreamFilter& filter)
277 result r = E_SUCCESS;
279 r = __pAudioStreamCoordinator->RemoveAudioStreamFilter(filter);
280 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
282 if (__pAudioStreamCoordinator->GetFilterListCount() == 0)
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;
295 _AudioRecorderImpl::CreateAudioFile(const Tizen::Base::String& mediaLocalPath, bool overwrite)
297 result r = E_SUCCESS;
298 RecorderState state = RECORDER_STATE_ERROR;
299 int err = ::RECORDER_ERROR_NONE;
300 SysLog(NID_MEDIA, "Creating audio file.");
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.",
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);
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);
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());
319 SetState(RECORDER_STATE_OPENED);
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));
333 _AudioRecorderImpl::Close(void)
335 result r = E_SUCCESS;
336 RecorderState state = RECORDER_STATE_ERROR;
337 SysLog(NID_MEDIA, "Audio recorder close.");
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.",
346 r = ChangeStateTo(::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL);
347 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
353 _AudioRecorderImpl::Record(void)
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");
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.",
365 mmState = GetMmState();
368 case ::RECORDER_STATE_CREATED:
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));
377 case ::RECORDER_STATE_READY:
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));
384 case ::RECORDER_STATE_PAUSED:
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));
400 case ::RECORDER_STATE_READY:
402 ChangeStateTo(::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL);
406 case ::RECORDER_STATE_PAUSED:
408 ChangeStateTo(::RECORDER_STATE_READY, _RECORDER_STATE_REASON_NORMAL);
409 ChangeStateTo(::RECORDER_STATE_CREATED, _RECORDER_STATE_REASON_NORMAL);
421 _AudioRecorderImpl::Stop(void)
423 result r = E_SUCCESS;
424 RecorderState state = RECORDER_STATE_ERROR;
425 SysLog(NID_MEDIA, "Stop audio recorder");
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.",
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));
441 _AudioRecorderImpl::Pause(void)
443 result r = E_SUCCESS;
444 RecorderState state = RECORDER_STATE_ERROR;
445 SysLog(NID_MEDIA, "Pause audio recorder");
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.",
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));
459 _AudioRecorderImpl::Cancel(void)
461 result r = E_SUCCESS;
462 RecorderState state = RECORDER_STATE_ERROR;
463 SysLog(NID_MEDIA, "Cancle audio recorder");
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);
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));
478 _AudioRecorderImpl::GetState(void) const
484 _AudioRecorderImpl::GetRecordingTime(void) const
490 _AudioRecorderImpl::GetRecordingSize(void) const
496 _AudioRecorderImpl::SetMaxRecordingTime(long msTime)
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);
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.",
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.",
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);
520 // For reload and Get the exact value
530 _AudioRecorderImpl::GetMaxRecordingTime(void) const
536 _AudioRecorderImpl::SetFormat(AudioRecordingFormat format)
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);
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.",
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);
557 GetMediaType(format, codec, container);
558 SysLog(NID_MEDIA, "format:%d, codec:0x%x, container:0x%x", format, codec, container);
560 r = _RecorderUtil::GetMmAudioCodec(codec, attrCodec);
561 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audio codec:0x%x", GetErrorMessage(r), codec);
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);
567 r = _RecorderUtil::GetMmFileFormat(container, attrFormat);
568 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. container:0x%x", GetErrorMessage(r), container);
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);
575 __audioCodec = codec;
576 __container = container;
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(
590 _AudioRecorderImpl::GetFormat(void) const
596 _AudioRecorderImpl::SetFormat(CodecType audioCodec, MediaContainerType container)
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);
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.",
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);
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);
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);
628 r = _RecorderUtil::GetMmAudioCodec(audioCodec, attrCodec);
629 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. audio codec:0x%x", GetErrorMessage(r), audioCodec);
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);
635 r = _RecorderUtil::GetMmFileFormat(container, attrFormat);
636 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. container:0x%x", GetErrorMessage(r), container);
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);
642 __audioCodec = audioCodec;
643 __container = container;
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);
655 _AudioRecorderImpl::GetFormat(CodecType& audioCodec, MediaContainerType& container) const
657 audioCodec = __audioCodec;
658 container = __container;
661 Tizen::Base::Collection::ArrayListT <CodecType>*
662 _AudioRecorderImpl::GetSupportedCodecListN(void) const
664 result r = E_SUCCESS;
665 _ResultType itemType = _RESULT_INTEGER_LIST;
666 SysLog(NID_MEDIA, "Get supported codec list of audio recorder");
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.");
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.");
675 r = pAudioCodecList->Construct();
676 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
678 for (int i = 0; i < pIntegerList->GetCount(); i++)
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);
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);
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());
693 return pAudioCodecList.release();
699 Tizen::Base::Collection::ArrayListT <MediaContainerType>*
700 _AudioRecorderImpl::GetSupportedContainerListN(void) const
702 result r = E_SUCCESS;
703 _ResultType itemType = _RESULT_INTEGER_LIST;
704 SysLog(NID_MEDIA, "get supported container list of audio recorder");
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.");
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.");
713 r = pContainerList->Construct();
714 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
716 for (int i = 0; i < pIntegerList->GetCount(); i++)
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);
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);
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());
731 return pContainerList.release();
738 _AudioRecorderImpl::SetQuality(RecordingQuality quality)
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;
748 SysLog(NID_MEDIA, "Enter. quality:%d", quality);
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);
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);
758 GetFormat(audioCodec, container);
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);
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);
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);
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);
775 // For keeping the quality of each format. SetQuality will be called again after SetFormat() is changing the format.
783 _AudioRecorderImpl::GetQuality(void) const
789 _AudioRecorderImpl::SetMute(bool mute)
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);
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);
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));
814 _AudioRecorderImpl::IsMuted(void) const
820 _AudioRecorderImpl::ConvertResult(int err) const
823 if (err != ::RECORDER_ERROR_NONE)
825 SysLog(NID_MEDIA, "MM Err:0x%x", err);
829 if (err == ::RECORDER_ERROR_NONE)
833 else if (err == ::RECORDER_ERROR_INVALID_PARAMETER)
837 else if (err == ::RECORDER_ERROR_INVALID_STATE)
841 else if (err == ::RECORDER_ERROR_OUT_OF_MEMORY)
845 else if (err == ::RECORDER_ERROR_DEVICE)
849 else if (err == ::RECORDER_ERROR_INVALID_OPERATION
850 || err == ::RECORDER_ERROR_SECURITY_RESTRICTED)
854 else if (err == ::RECORDER_ERROR_SOUND_POLICY)
867 _AudioRecorderImpl::SetState(RecorderState state)
873 _AudioRecorderImpl::SetRecordingTime(long recTime)
879 _AudioRecorderImpl::SetRecordingSize(long recSize)
885 _AudioRecorderImpl::GetMediaType(AudioRecordingFormat format, CodecType& codec, MediaContainerType& container) const
889 case AUDIORECORDING_FORMAT_DEFAULT:
891 case AUDIORECORDING_FORMAT_AMR:
893 codec = CODEC_AMR_NB;
894 container = MEDIA_CONTAINER_AMR;
898 case AUDIORECORDING_FORMAT_WAVE:
901 container = MEDIA_CONTAINER_WAV;
908 container = MEDIA_CONTAINER_NONE;
915 _AudioRecorderImpl::GetMediaType(MediaContainerType container, AudioRecordingFormat& format) const
919 case MEDIA_CONTAINER_AMR:
921 format = AUDIORECORDING_FORMAT_AMR;
925 case MEDIA_CONTAINER_WAV:
927 format = AUDIORECORDING_FORMAT_WAVE;
933 format = AUDIORECORDING_FORMAT_DEFAULT;
940 _AudioRecorderImpl::ReloadConfiguration(int reload)
942 result r = E_SUCCESS;
943 int err = ::RECORDER_ERROR_NONE;
945 SysLog(NID_MEDIA, "Enter. reload:0x%x", reload);
947 if (reload & _RELOAD_FORMAT)
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);
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);
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);
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);
965 if (reload & _RELOAD_QUALITY)
967 int attrSamplerate = 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);
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);
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);
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);
985 if (reload & _RELOAD_MAX_TIME)
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));
993 if (reload & _RELOAD_INIT)
1007 _AudioRecorderImpl::GetMmState(void) const
1009 result r = E_SUCCESS;
1010 int err = ::RECORDER_ERROR_NONE;
1011 recorder_state_e mmState = ::RECORDER_STATE_NONE;
1013 err = recorder_get_state(__handle, &mmState);
1014 r = ConvertResult(err);
1015 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1020 return ::RECORDER_STATE_NONE;
1024 _AudioRecorderImpl::ChangeStateTo(recorder_state_e mmDestState, _RecorderStateChangeReason reason)
1026 result r = E_SUCCESS;
1027 int tableTotalCount = 0;
1029 int err = MM_SUCCESS;
1030 recorder_state_e preState = ::RECORDER_STATE_NONE;
1031 recorder_state_e postState = ::RECORDER_STATE_NONE;
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);
1037 for (i = 0; i < tableTotalCount; i++)
1039 if (preState == _AUDIO_COMMAND_STATE[i].prevState && mmDestState == _AUDIO_COMMAND_STATE[i].postState && reason ==
1040 _AUDIO_COMMAND_STATE[i].reason)
1042 if (_AUDIO_COMMAND_STATE[i].pFunc != null)
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);
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,
1056 SysLog(NID_MEDIA, "[E_SUCCESS] Found. result postState:%d, param mmDestState:%d", postState, mmDestState);
1058 __stateChangeReason = reason; //for distinguish between stop and cancel and end reach.
1061 if (_AUDIO_COMMAND_STATE[i].state >= RECORDER_STATE_INITIALIZED && _AUDIO_COMMAND_STATE[i].state <= RECORDER_STATE_ERROR)
1063 SysLog(NID_MEDIA, "State set to %d", _AUDIO_COMMAND_STATE[i].state);
1064 SetState(_AUDIO_COMMAND_STATE[i].state);
1070 SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
1074 SysLog(NID_MEDIA, "[%s] Real preState:%d, param mmDestState:%d", GetErrorMessage(r), preState, mmDestState);
1078 _RecorderStateChangeReason
1079 _AudioRecorderImpl::GetStateChangeReason(void) const
1081 return __stateChangeReason;
1084 _AudioRecorderEvent*
1085 _AudioRecorderImpl::GetEvent(void) const
1087 return __pAudioRecorderEvent.get();
1091 _AudioRecorderImpl::StateChangedCb(recorder_state_e previous, recorder_state_e current, bool byPolicy, void* pUserData)
1093 result r = E_SUCCESS;
1094 _AudioRecorderImpl* pObj = static_cast<_AudioRecorderImpl*>( pUserData);
1095 int tableTotalCount = 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);
1101 tableTotalCount = sizeof(_AUDIO_CALLBACK_EVENT) / sizeof(_AUDIO_CALLBACK_EVENT[0]);
1103 for (i = 0; i < tableTotalCount; i++)
1105 if (previous == _AUDIO_CALLBACK_EVENT[i].prevState && current == _AUDIO_CALLBACK_EVENT[i].postState && pObj->GetStateChangeReason() == _AUDIO_CALLBACK_EVENT[i].reason)
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);
1112 SysTryReturnVoidResult(NID_MEDIA, i != tableTotalCount, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Not found. ");
1116 _AudioRecorderImpl::RecordingStatusCb(unsigned long long elapsedTime, unsigned long long fileSize, void *pUserData)
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.");
1122 SysLog(NID_MEDIA, " FileSize:%llu,elapsedTime:%llu",fileSize,elapsedTime);
1124 pObj->SetRecordingTime((long)elapsedTime);
1125 pObj->SetRecordingSize((long)fileSize);
1129 _AudioRecorderImpl::AudioStreamCb(void* pStream, int size, audio_sample_type_e format, int channel, unsigned int timeStamp, void *pUserData)
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.");
1137 if (pObj->__audioStreamCallback == true)
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));
1145 _AudioRecorderImpl::LimitReachedCb(recorder_recording_limit_type_e type, void *pUserData)
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.");
1152 SysLog(NID_MEDIA, "Type:%d", type);
1156 case ::RECORDER_RECORDING_LIMIT_TIME:
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));
1163 case ::RECORDER_RECORDING_LIMIT_SIZE:
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));
1170 case ::RECORDER_RECORDING_LIMIT_FREE_SPACE:
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));
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));
1189 _AudioRecorderImpl::ErrorCb(recorder_error_e error, recorder_state_e state, void *pUserData)
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.");
1196 SysLog(NID_MEDIA, "Error:%d, state:%d", error, state);
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));
1205 _AudioRecorderImpl::InterruptedCb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *pUserData)
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.");
1211 SysLog(NID_MEDIA, "Policy:%d, previous:%d, current:%d", policy, previous, current);
1215 _AudioRecorderImpl::IsAlive(void)
1221 _AudioRecorderImpl::GetInstance(AudioRecorder *pAudioRecorder)
1223 if ( pAudioRecorder !=null )
1225 return pAudioRecorder->__pImpl;
1230 const _AudioRecorderImpl*
1231 _AudioRecorderImpl::GetInstance(const AudioRecorder *pAudioRecorder)
1233 if ( pAudioRecorder !=null )
1235 return pAudioRecorder->__pImpl;