/*
* Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  This class is a RecordControl.
*
*/


#ifndef CMMARECORDCONTROL_H
#define CMMARECORDCONTROL_H

//  INTERNAL INCLUDES
#include <f32file.h>
#include "cmmaoutputstream.h"
#include "cmmacontrol.h"
#include "mmmaplayerstatelistener.h"

//  FORWARD DECLARATIONS
class CMMAPlayer;

// CONSTANTS

// Too fast start and stop can cause problems,
// 0.5s is enough to make pause work.
const TInt KMinRecordPauseInterval = 500000;

_LIT(KMMARecordTempDirectory, "d:\\");   // CSI: 25 dir for temporary recording file #
_LIT(KMMARecordErrorMsg, "Recording error: %d");
const TInt KRecordErrorMessageSize = 25;

//  CLASS DECLARATION
/**
*   This class is the native side of the RecordControl Java class. This class
*   delegates static method calls to virtual methods which are implemented in
*   derived classes. This class only implements ClassName method.
*
*
*/
NONSHARABLE_CLASS(CMMARecordControl):
        public CMMAControl,
        public MMMAPlayerStateListener
{
protected:
    // Internal state of this class.
    enum TRecordState
    {
        // recorder has not been initialized (startRecord has not been called)
        ERecordUninitialized = 1,       //Recorder uninitialized
        // recorder has been initialized (startRecord) however,
        // recodring has been stopped after that (stopRecord)
        ERecordInitialized,
        // recorder has been initialized (startRecord) but player is not in
        // STARTED state
        ERecordStandBy,
        // recorder has been initialized (startRecord) and player is in
        // STARTED state. i.e. recording is ON
        ERecordRecording
    };

protected: // proteced constructor and destructor for preventing direct use
    CMMARecordControl(CMMAPlayer* aPlayer);
    ~CMMARecordControl();
    void ConstructL();

    /**
     * Waits until recording can be paused after start.
     * @param aMediaTime Current media time.
     */
    void WaitForPauseL(const TInt64& aMediaTime);

public: // new methods
    /**
     * Start recording.
     */
    virtual void StartRecordL();

    /**
     * Stops recording.
     */
    virtual void StopRecordL();

    /**
     * Completes current recording. The rest of the data will written
     * to the output stream. This method may not be called when recording.
     */
    virtual void CommitL();

    /**
     * Erase current recording.
     */
    virtual void ResetL();

    /**
     * Set the output stream where the data will be recorded.
     * Existing stream will be deleted.
     * @param aStream New stream to use.
     */
    virtual void SetRecordStream(CMMAOutputStream* aStream);

    /**
     * Return the content type of the recorded media.
     * @return Content type used for recording.
     */
    virtual HBufC* GetContentTypeL();

public: // new pure virtual methods

    /**
     * Set the record size limit. This limits the size of the recorded
     * media to the number of bytes specified.
     *
     * When recording is in progress, commit will be called implicitly
     * in the following cases:
     *  - Record size limit is reached
     *  - If the requested size is less than the already recorded size
     *  - No more space is available.
     *
     * Once a record size limit has been set,
     * it will remain so for future recordings until it is
     * changed by another setRecordSizeLimit call.
     *
     * @param aSize New size limit.
     * @return Actual value set.
     */
    virtual TInt SetRecordSizeLimitL(TInt aSize) = 0;

    /**
     *  Start the recording in implementation
     */
    virtual void DoStartRecordL() = 0;

    /**
     *  Start the recording in implementation
     */
    virtual void DoStopRecordL() = 0;

    /**
     *  Initialize native recorder
     */
    virtual void InitializeL() = 0;

    /**
     *  Reset recorder
     */
    virtual void DoResetL() = 0;

public: // From CMMAControl
    const TDesC& ClassName() const;


public: // from MMMAPlayerListener
    void StateChanged(TInt aState);

protected: // new methods
    /**
     * Sends record error event to Java
     */
    void Error(TInt aErrorCode);

    /**
     * Handles situation when record size limit is reached
     */
    void HandleRecordSizeLimit();

private: // new methods
    void NextStateL(TInt aPlayerState);

protected: // Members
    // Current state of recording
    TRecordState iState;

    // Where to record
    RFile iFile;
    TFileName iFilename;

    // Recording player
    CMMAPlayer* iPlayer;

    // Rfs used for creating temp file and deleting it
    RFs iFs;
private: // Members

    // Stream to write data, owned
    CMMAOutputStream* iOutputStream;

    /**
     * Start time of recording.
     */
    TInt64 iStartTime;

    /**
     * Owned. Used to wait before pause if it
     * is called too fast after starting.
     */
    RTimer iRecordPauseTimer;
};


#endif // CMMARECORDCONTROL_H