src/FMedia_AudioRecorderImpl.h

   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.h
  20  * @brief               This header file contains the declaration of the _AudioRecorder_Impl class.
  21  */
  22
  23 #ifndef _FMEDIA_INTERNAL_AUDIORECORDER_IMPL_H_
  24 #define _FMEDIA_INTERNAL_AUDIORECORDER_IMPL_H_
  25
  26 #include <unique_ptr.h>
  27 #include <FBaseColArrayListT.h>
  28 #include <FMediaTypes.h>
  29 #include <FMediaAudioRecorderTypes.h>
  30 #include "FMedia_RecorderTypes.h"
  31
  32 namespace Tizen { namespace Media
  33 {
  34 class AudioRecorder;
  35 class IAudioRecorderEventListener;
  36 class _AudioRecorderEvent;
  37 class _RecorderManager;
  38 class _AudioStreamCoordinator;
  39 class IAudioStreamFilter;
  40
  41 /**
  42  * @class       _AudioRecorderImpl
  43  * @brief       This class records the audio data into a file.
  44  */
  45
  46 class _AudioRecorderImpl
  47         : public Tizen::Base::Object
  48 {
  49
  50 public:
  51         /**
  52          * This is the default constructor for this class.
  53          *
  54          * @remarks             After creating an instance of this class, the Construct() method must be called explicitly to
  55          *              initialize this instance.
  56          * @see         Construct()
  57          */
  58         _AudioRecorderImpl(void);
  59
  60         /**
  61          * This is the destructor for this class. @n
  62          * All allocated resources are released by this method. This method should be called in the same thread in
  63          * which the Construct() method is called.
  64          *
  65          * @see     Construct()
  66          */
  67         virtual ~_AudioRecorderImpl(void);
  68
  69
  70 public:
  71         /**
  72         * Initializes this instance of %_AudioRecorderImpl with the specified listener.
  73         *
  74         * @return               An error code
  75         * @param[in]    listener                        An event listener instance
  76         * @exception    E_SUCCESS                       The method is successful.
  77         * @exception    E_INVALID_STATE     This instance is in an invalid state for this method.
  78         * @exception    E_SYSTEM                        A system error has occurred.
  79         * @exception    E_DEVICE_BUSY           The device cannot be approached because of other operations.
  80         */
  81         result Construct(IAudioRecorderEventListener& listener);
  82
  83         /**
  84         * Creates an audio file for the recording.
  85         *
  86         * @return               An error code
  87         * @param[in]    destMediaPath                   The file destination to write @n
  88         *                                                                               The available paths start with prefixes retrieved from the functions such as: @n
  89         *                                                                               Tizen::App::App::GetInstance()->GetAppRootPath() @n
  90         *                                                                               Tizen::System::Environment::GetMediaPath() @n
  91         *                                                                               Tizen::System::Environment::GetExternalStoragePath()
  92         * @param[in]    overwrite                   Set to @c true to overwrite a file if it already exists, @n
  93         *                                                                               else @c false
  94         * @exception    E_SUCCESS                               The method is successful.
  95         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
  96         * @exception    E_RESOURCE_UNAVAILABLE  The required path is unavailable.
  97         * @exception    E_SYSTEM                                A system error has occurred.
  98         * @exception    E_FILE_ALREADY_EXIST    The specified file already exists.
  99         * @exception    E_STORAGE_FULL                  The storage is full.
 100         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 101         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 102         * @see Close()
 103         */
 104         result CreateAudioFile(const Tizen::Base::String& destMediaPath, bool overwrite);
 105
 106         /**
 107         * Closes a file.
 108         *
 109         * @return               An error code
 110         * @exception    E_SUCCESS                               The method is successful.
 111         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 112         * @exception    E_SYSTEM                                A system error has occurred.
 113         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 114         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 115         * @see                  CreateAudioFile()
 116         * @remarks      This method is synchronous.
 117         */
 118         result Close(void);
 119
 120         /**
 121         * Starts recording or resumes a recording after Pause() is called.
 122         *
 123         * @return           An error code
 124         * @exception    E_SUCCESS                               The method is successful.
 125         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 126         * @exception    E_SYSTEM                                A system error has occurred.
 127         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
 128         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 129         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 130         * @see                  Stop(), Pause()
 131         */
 132         result Record(void);
 133
 134         /**
 135         * Stops a recording.
 136         *
 137         * @return               An error code
 138         * @exception    E_SUCCESS                               The method is successful.
 139         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 140         * @exception    E_SYSTEM                                A system error has occurred.
 141         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 142         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 143         * @see                  Record(), Pause()
 144         */
 145         result Stop(void);
 146
 147         /**
 148         * Pauses a recording. @n
 149         * To resume a recording after this method is called, the Record() method must be called.
 150         *
 151         * @return               An error code
 152         * @exception    E_SUCCESS                               The method is successful.
 153         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 154         * @exception    E_SYSTEM                                A system error has occurred.
 155         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 156         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 157         * @see                  Record(), Stop()
 158         */
 159         result Pause(void);
 160
 161         /**
 162         * Cancels a recording operation without saving the data.
 163         *
 164         * @return           An error code
 165         * @exception    E_SUCCESS                               The method is successful.
 166         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 167         * @exception    E_SYSTEM                                A system error has occurred.
 168         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 169         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 170         * @remarks      If this method is called, the state is changed to ::RECORDER_STATE_STOPPING. @n
 171         *                       After IAudioRecorderEventListener::OnAudioRecorderCanceled() is called, the state is changed
 172         *                       to ::RECORDER_STATE_STOPPED.
 173         * @see          Record(), Stop()
 174         */
 175         result Cancel(void);
 176
 177         /**
 178         * Gets the state of an audio recorder.
 179         *
 180         * @return           The current state of an audio recorder
 181         * @exception    E_SUCCESS                               The method is successful.
 182         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 183         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 184         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 185         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 186         * @see                  CreateAudioFile(), Close(), Record(), Stop(), Pause()
 187         */
 188         RecorderState GetState(void) const;
 189
 190         /**
 191         * Gets the current recording time.
 192         *
 193         * @return           The value indicating the current recording time in milliseconds, @n
 194         *                               else @c -1 if the recording has not started as yet
 195         * @exception    E_SUCCESS                               The method is successful.
 196         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 197         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 198         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 199         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 200         */
 201         long GetRecordingTime(void) const;
 202
 203         /**
 204         * Gets the current recording size.
 205         *
 206         * @return               The value indicating the current recording size in bytes, @n
 207         *                               else @c -1 if the recording has not started as yet
 208         * @exception    E_SUCCESS                               The method is successful.
 209         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 210         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 211         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 212         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 213         */
 214         long GetRecordingSize(void) const;
 215
 216         /**
 217         * Sets the recording time limit for a file in milliseconds.
 218         *
 219         * @return               An error code
 220         * @param[in]    msTime          The maximum recording time in milliseconds @n
 221         *                                                       The time must be greater than @c 0.
 222         * @exception    E_SUCCESS                               The method is successful.
 223         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 224         * @exception    E_OUT_OF_RANGE                  The specified time is out of range.
 225         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 226         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 227         * @remarks              The default time is @c 60 seconds.
 228         * @see                  GetMaxRecordingTime()
 229         */
 230         result SetMaxRecordingTime(long msTime);
 231
 232         /**
 233         * Gets the recording time limit of a file in milliseconds.
 234         *
 235         * @return               A @c long value indicating the maximum recording time in milliseconds
 236         * @exception    E_SUCCESS                               The method is successful.
 237         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 238         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 239         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 240         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 241         * @see                  SetMaxRecordingTime()
 242         */
 243         long GetMaxRecordingTime(void) const;
 244
 245         /**
 246         * Sets the audio format of an audio recorder. @n
 247         * Initially, the default format is set using the internal configuration.
 248         *
 249         * @return               An error code
 250         * @param[in]    format          The audio format to set @n
 251         *                                                       ::AUDIORECORDING_FORMAT_DEFAULT sets the system's default recording format.
 252         * @exception    E_SUCCESS                               The method is successful.
 253         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 254         * @exception    E_UNSUPPORTED_FORMAT    The specified format is not supported.
 255         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 256         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 257         * @see                  GetFormat()
 258         */
 259         result SetFormat(AudioRecordingFormat format);
 260
 261         /**
 262         * Gets the audio recording format of an audio recorder.
 263         *
 264         * @return               The audio recording format, @n
 265         *               else default format if SetFormat() is not called before calling this method
 266         * @exception    E_SUCCESS                               The method is successful.
 267         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 268         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 269         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 270         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 271         * @see                  SetFormat()
 272         */
 273         AudioRecordingFormat GetFormat(void) const;
 274
 275         /**
 276         * Sets the audio codec and the container of an audio recorder. @n
 277         * Initially, the default codec and the container format are set using the internal configuration.
 278         *
 279         * @return               An error code
 280         * @param[in]    audioCodec                              The audio codec to set
 281         * @param[in]    container                               The media container to set
 282         * @exception    E_SUCCESS                               The method is successful.
 283         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 284         * @exception    E_UNSUPPORTED_CODEC             The specified codec is not supported.
 285         * @exception    E_UNSUPPORTED_FORMAT    The specified container format is not supported.
 286         * @exception    E_SYSTEM                                A system error has occurred.
 287         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 288         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 289         * @remarks              If the specified container does not support the specified codec, E_UNSUPPORTED_FORMAT may be thrown.
 290         * @see                  GetFormat( CodecType& audioCodec, MediaContainerType& container ) const
 291         */
 292         result SetFormat(CodecType audioCodec, MediaContainerType container);
 293
 294         /**
 295         * Gets the audio codec and container of an audio recorder.
 296         *
 297         * @return               An error code
 298         * @param[out]   audioCodec                      The retrieved audio codec
 299         * @param[out]   container                       The retrieved container
 300         * @remarks              If SetFormat(CodecType audioCodec, MediaContainerType container) is not called before calling
 301         *                               this method, the default codec and container are retrieved.
 302         * @see                  SetFormat( CodecType audioCodec, MediaContainerType container )
 303         */
 304         void GetFormat(CodecType& audioCodec, MediaContainerType& container) const;
 305
 306         /**
 307         * Gets a list of the supported audio codecs. @n
 308         * Each list's item has a ::CodecType value.
 309         *
 310         * @return       A list of supported audio codecs, @n
 311         *                               else @c null if no codec is supported or if an exception occurs
 312         * @exception    E_SUCCESS                               The method is successful.
 313         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 314         * @exception    E_SYSTEM                                A system error has occurred.
 315         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 316         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 317         * @remarks              The specific error code can be accessed using the GetLastResult() method. @n
 318         *               The return value must be released by the caller.
 319         * @see                  SetFormat(CodecType audioCodec, MediaContainerType container), GetFormat(CodecType&
 320         *                               audioCodec, MediaContainerType& container) const
 321         */
 322         Tizen::Base::Collection::ArrayListT <CodecType>* GetSupportedCodecListN(void) const;
 323
 324         /**
 325         * Gets a list of the supported containers. @n
 326         * Each list's item has a ::MediaContainerType value.
 327         *
 328         * @return       A list of supported container list, @n
 329         *                               else @c null if no container is supported or if an exception occurs
 330         * @exception    E_SUCCESS                       The method is successful.
 331         * @exception    E_INVALID_STATE         This instance is in an invalid state for this method.
 332         * @exception    E_SYSTEM                        A system error has occurred.
 333         * @exception    E_OUT_OF_MEMORY         The memory is insufficient.
 334         * @exception    E_PRIVILEGE_DENIED      The application does not have the privilege to call this method.
 335         * @remarks              The specific error code can be accessed using the GetLastResult() method. @n
 336         *               The return value must be released by the caller.
 337         * @see                  SetFormat(CodecType audioCodec, MediaContainerType container), GetFormat(CodecType&
 338         *                               audioCodec, MediaContainerType& container) const
 339         */
 340         Tizen::Base::Collection::ArrayListT <MediaContainerType>* GetSupportedContainerListN(void) const;
 341
 342         /**
 343         * Sets the audio recording quality of the audio recorder.
 344         *
 345         * @return               An error code
 346         * @param[in]    quality                         The audio recording quality of the audio recorder @n
 347         *                                                                       The default value is ::RECORDING_QUALITY_MEDIUM.
 348         * @exception    E_SUCCESS                       The method is successful.
 349         * @exception    E_INVALID_STATE         This instance is in an invalid state for this method.
 350         * @exception    E_INVALID_ARG           The specified @c quality is not supported.
 351         * @exception    E_OUT_OF_MEMORY         The memory is insufficient.
 352         * @exception    E_PRIVILEGE_DENIED      The application does not have the privilege to call this method.
 353         * @see                  GetQuality()
 354         */
 355         result SetQuality(RecordingQuality quality);
 356
 357         /**
 358         * Gets the audio recording quality of the audio recorder.
 359         *
 360         * @return               The current audio recording quality of the audio recorder
 361         * @exception    E_SUCCESS                               The method is successful.
 362         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 363         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 364         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 365         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 366         * @see                  SetQuality()
 367         */
 368         RecordingQuality GetQuality(void) const;
 369
 370         /**
 371         * Enables or disables the mute state of an audio recorder.
 372         *
 373         * @return               An error code
 374         * @param[in]    mute                The mute state @n
 375         *                                                                       By default, the mute state is disabled.
 376         * @exception    E_SUCCESS                       The method is successful.
 377         * @exception    E_INVALID_STATE         This instance is in an invalid state for this method.
 378         * @exception    E_OUT_OF_MEMORY         The memory is insufficient.
 379         * @exception    E_PRIVILEGE_DENIED      The application does not have the privilege to call this method.
 380         * @remarks              The audio recording continues even though the audio recorder is in the mute state.
 381         * @see                  IsMuted()
 382         */
 383         result SetMute(bool mute);
 384
 385         /**
 386         * Checks whether the mute state is enabled for an audio recorder.
 387         *
 388         * @return               @c true if the audio recorder is not recording any sound, @n
 389         *                               else @c false
 390         * @exception    E_SUCCESS                               The method is successful.
 391         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 392         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 393         * @exception    E_PRIVILEGE_DENIED              The application does not have the privilege to call this method.
 394         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 395         * @see                  SetMute()
 396         */
 397         bool IsMuted(void) const;
 398
 399         /**
 400         * Sets the state.
 401         *
 402         * @param[in]    state           new _AudioRecorder's state
 403         */
 404         void SetState(RecorderState state);
 405
 406         /**
 407         * Sets the recording time
 408         *
 409         * @param[in]    recTime             recording time in milliseconds
 410         */
 411         void SetRecordingTime(long recTime);
 412
 413         /**
 414         * Sets the recording size
 415         *
 416         * @param[in]    recSize             recording size in bytes
 417         */
 418         void SetRecordingSize(long recSize);
 419
 420         /**
 421         * Gets the new media type from the old type.
 422         *
 423         * @param[in]    format          recording type
 424         * @param[out]   codec           codec type matching the input format
 425         * @param[out]   container       container type matching the input format
 426         *
 427         */
 428         void GetMediaType(AudioRecordingFormat format, CodecType& codec, MediaContainerType& container) const;
 429
 430         /**
 431         * Gets the old media type from the new type.
 432         *
 433         * @param[in]    container       container type
 434         * @param[out]   format          format type  matching the input container
 435         *
 436         */
 437         void GetMediaType(MediaContainerType container, AudioRecordingFormat& format) const;
 438
 439         /**
 440         * Gets the recorder's state.
 441         *
 442         * @return           The state
 443         *
 444         */
 445         recorder_state_e GetMmState(void) const;
 446
 447         /**
 448         * Get the event processing object.
 449         *
 450         * @return       The event processing object.
 451         * @remarks      This event is working synchronously.
 452         */
 453         _AudioRecorderEvent* GetEvent(void) const;
 454
 455         /**
 456         * Message callback function
 457         *
 458         * @param[in]    previous         Previous recorder state
 459         * @param[in]    current         Current recorder state
 460         * @param[in]    byPolicy                true if the state is changed by policy, otherewise false
 461         * @param[in]    pUserData               User data
 462          */
 463         static void StateChangedCb(recorder_state_e previous, recorder_state_e current, bool byPolicy, void* pUserData);
 464
 465         /**
 466         * Recording Status callback function
 467         *
 468         * @param[in]    elapsedTime      recording time elapsed
 469         * @param[in]    fileSize         size of file written
 470         * @param[in]    pUserData        User data
 471          */
 472         static void RecordingStatusCb(unsigned long long elapsedTime, unsigned long long fileSize, void *pUserData);
 473
 474         /**
 475         * Audio stream callback function
 476         *
 477         * @param[in]    pStream          Stream data
 478         * @param[in]    format          Sample format
 479         * @param[in]    channel         Sample channel
 480         * @param[in]    timeStampl      The time stamp
 481         * @param[in]    pUserData               User data
 482          */
 483         static void AudioStreamCb(void* pStream, int size, audio_sample_type_e format, int channel, unsigned int timeStamp, void *pUserData);
 484
 485         /**
 486         * Limit reached callback function
 487         *
 488         * @param[in]    type          Limit reached reason
 489         * @param[in]    pUserData               User data
 490          */
 491         static void LimitReachedCb(recorder_recording_limit_type_e type, void *pUserData);
 492
 493         /**
 494         * Message callback function
 495         *
 496         * @param[in]    error                   Error reason
 497         * @param[in]    state           Error state
 498         * @param[in]    pUserData               User data
 499          */
 500         static void ErrorCb(recorder_error_e error, recorder_state_e state, void *pUserData);
 501
 502         /**
 503         * Message callback function
 504         *
 505         * @param[in]    policy          The policy which occurs the interruption
 506         * @param[in]    previous                Previous recorder state
 507         * @param[in]    current         Current recorder state
 508         * @param[in]    pUserData               User data
 509          */
 510         static void InterruptedCb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *pUserData);
 511
 512         /**
 513          * Function check fo this object is alive.
 514          *
 515          * @return              true if the object is alive, otherwise false.
 516          */
 517         static bool IsAlive(void);
 518
 519         /**
 520          * Gets the Impl instance.
 521          *
 522          * @return              The pointer to %_AudioRecorderImpl
 523          * @param[in]   pAudioRecorder          The %AudioRecorder pointer
 524          */
 525         static _AudioRecorderImpl* GetInstance(AudioRecorder *pAudioRecorder);
 526
 527         /**
 528          * Gets the Impl instance.
 529          *
 530          * @return              The pointer to %_AudioRecorderImpl
 531          * @param[in]   pAudioRecorder          The %AudioRecorder pointer
 532          */
 533         static const _AudioRecorderImpl* GetInstance(const AudioRecorder *pAudioRecorder);
 534
 535         /**
 536         * Adds the stream filter to process the audio stream data while recording.
 537         *
 538         * @return               An error code
 539         * @param[in]    filter                  An instance of IAudioStreamFilter
 540         * @exception    E_SUCCESS                       The method is successful.
 541         * @exception    E_OBJ_ALREADY_EXIST     The filter already exists.
 542         * @exception    E_OUT_OF_MEMORY     The memory is insufficient.
 543         */
 544         result AddAudioStreamFilter(IAudioStreamFilter& filter);
 545
 546         /**
 547         * Removes the stream filter to stop processing the audio stream data.
 548         *
 549         * @return               An error code
 550         * @param[in]    filter                  An instance of IAudioStreamFilter
 551         * @exception    E_SUCCESS                       The method is successful.
 552         * @exception    E_OBJ_NOT_FOUND        The filter is not found.
 553         */
 554         result RemoveAudioStreamFilter(IAudioStreamFilter& filter);
 555
 556 private:
 557         /**
 558         * Converts the error from recorder to Result.
 559         *
 560         * @return       An error code
 561         * @param[in]    err             recorder error
 562         */
 563         result ConvertResult(int err) const;
 564
 565         /**
 566         * Transfer the state.
 567         *
 568         * @return       An error code
 569         * @param[in]    mmDestState             recorder's destinationed state
 570         * @param[in]    reason           state changed reason
 571         * @remarks      This method makes the recorder's state change. @n
 572         *                       Sometimes, acccording to this, Recorder's state is changed.
 573         */
 574         result ChangeStateTo(recorder_state_e mmDestState, _RecorderStateChangeReason reason);
 575
 576         /**
 577         * Checks the operation is for completing.
 578         *
 579         * @return               The state change reason
 580         * @remarks      If the Cancel() is called, this value is false, because the Record() is not completed.
 581         */
 582         _RecorderStateChangeReason GetStateChangeReason(void) const;
 583
 584         /**
 585         * Re-load configuration.
 586         *
 587         * @return       An error code
 588         * @param[in]    reload                  reload configuration field
 589         * @exception    E_SUCCESS                               The method is successful.
 590         * @exception    E_SYSTEM                                A system error has occurred.
 591         * @remarks      Multiple configuration field can be set using reloadConf parameter appending.
 592         */
 593         result ReloadConfiguration(int reload);
 594
 595         _AudioRecorderImpl(const _AudioRecorderImpl&);
 596         _AudioRecorderImpl& operator =(const _AudioRecorderImpl& _AudioRecorderImpl);
 597
 598         std::unique_ptr <_AudioRecorderEvent> __pAudioRecorderEvent;
 599         IAudioRecorderEventListener* __pAudioRecorderEventListener;
 600         _RecorderManager* __pRecorderManager;
 601         bool __isConstructed;
 602         RecorderState __state;
 603         long __recTime;
 604         long __recSize;
 605         long __maxTime;
 606         AudioRecordingFormat __format;
 607         CodecType __audioCodec;
 608         MediaContainerType __container;
 609         RecordingQuality __quality;
 610         bool __mute;
 611         _RecorderHandle __handle;
 612         _RecorderStateChangeReason __stateChangeReason;
 613         static bool __isUsed;
 614         std::unique_ptr <_AudioStreamCoordinator> __pAudioStreamCoordinator;
 615         int __audioStreamTimeDuration;
 616         bool __audioStreamCallback;
 617 };
 618
 619 }}// Tizen::Media
 620
 621 #endif