/*

* Copyright (c) 2002 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:  Camcorder controller plugin

*

*/

// INCLUDE FILES

#include <mmf/common/mmfcontroller.h>

#include <mmf/common/mmfstandardcustomcommands.h>

#include <mmf/server/mmffile.h>

#include <badesca.h>    // CDesC8ArrayFlat

#include <AudioPreference.h>                // For MMF audio preference definitions.

#include "CamC3GPDataSink.h"

#include "CCMRMediaRecorder.h"

#include "CamC3GPDataSinkObserver.h"

#include "CamCController.h"

#include "CCMRSupportedCodecs.h"

#include "CamCImplementationUIDs.hrh"

#include "CamCControllerCustomCommands.h"

// LOCAL CONSTANTS AND MACROS

// Debug print macro

#if defined _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x;

#else

#define PRINT(x)

#endif

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CCamCController::NewL

// Two-phased constructor.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

CCamCController* CCamCController::NewL()

    {

    PRINT((_L("CCamCController::NewL() in ")));

    CCamCController* self = new(ELeave) CCamCController();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    PRINT((_L("CCamCController::NewL() out ")));

    return self;

    }

// -----------------------------------------------------------------------------

// CCamCController::~CCamCController

// Destructor

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

CCamCController::~CCamCController()

    {

    PRINT((_L("CCamCController::~CCamCController enter      ")));

    delete iMediaRecorder;

    iMediaRecorder = NULL;

    PRINT((_L("CCamCController::~CCamCController mediarecorder deleted      ")));

    delete iFileComposer;

    iFileComposer = NULL;

    PRINT((_L("CCamCController::~CCamCController filecomposer deleted      ")));

    delete iVideoCodec;

    iVideoCodec = NULL;

    if ( iSupportedVideoTypes )

        {

        iSupportedVideoTypes->Reset();

        delete iSupportedVideoTypes;

        iSupportedVideoTypes = NULL;

        }

    iSupportedAudioTypes.Close();

    delete iIdleStop;

    PRINT((_L("CCamCController::~CCamCController exit      ")));

    }

// -----------------------------------------------------------------------------

// CCamCController::ConstructL

// Symbian 2nd phase constructor can leave.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCamCController::ConstructL()

    {

    PRINT((_L("CCamCController::ConstructL() in")));

    iMediaRecorder = NULL;

    iFileComposer = NULL;

    iState = EStateNone;

    iVideoCodec = 0;

    iAudioCodec = 0;

    iCameraHandle = -1;

    iVideoFormat = CCamC3GPDataSink::E3GPP;

    iFileComposerReady = EFalse;

    iMRPrepareCompleteSent = EFalse;

    iForceDataSinkFileName = EFalse;

    iSavedStopError = KErrNone;

    iAsyncStop = EFalse;

    iPrioritySettings.iPriority = KAudioPriorityVideoRecording;

    iPrioritySettings.iPref =  TMdaPriorityPreference( KAudioPrefVideoRecording );

    iSupportedVideoTypes = new(ELeave) CDesC8ArrayFlat( 2 ); // 2 is the granularity of the array

    iSupportedVideoTypes->Reset();

    iSupportedAudioTypes.Reset();

    //custom command parsers

    CMMFVideoControllerCustomCommandParser* vidConPaser =

                                        CMMFVideoControllerCustomCommandParser::NewL(*this);

    CleanupStack::PushL(vidConPaser);

    AddCustomCommandParserL(*vidConPaser); //parser now owned by controller framework

    CleanupStack::Pop(vidConPaser);

    CMMFVideoRecordControllerCustomCommandParser* vidRecParser =

                                        CMMFVideoRecordControllerCustomCommandParser::NewL(*this);

    CleanupStack::PushL(vidRecParser);

    AddCustomCommandParserL(*vidRecParser); //parser now owned by controller framework

    CleanupStack::Pop(vidRecParser);

    CMMFAudioRecordDeviceCustomCommandParser* audRecParser =

                                        CMMFAudioRecordDeviceCustomCommandParser::NewL(*this);

    CleanupStack::PushL(audRecParser);

    AddCustomCommandParserL(*audRecParser); //parser now owned by controller framework

    CleanupStack::Pop(audRecParser);

    // Idle priority Active object for async video stop operation

    iIdleStop = CIdle::NewL( CActive::EPriorityIdle );

    PRINT((_L("CCamCController::ConstructL() out")));

    }

// -----------------------------------------------------------------------------

// CCamCController::AddDataSourceL

// Add data source to controller.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCamCController::AddDataSourceL(MDataSource& aDataSource)

    {

    PRINT((_L("CCamCController::AddDataSourceL() in")));

    if( iState != EStateNone )

        {

        User::Leave( KErrNotReady );

        }

    if (!iMediaRecorder)

        {

        iMediaRecorder = CCMRMediaRecorder::NewL();

        }

    if (aDataSource.DataSourceType()==KUidMmfAudioInput)

        {

        iAudioSource = &aDataSource;

        }

    if ( ReadyToOpenSource() )

        {

        OpenSourceL();

        }

    PRINT((_L("CCamCController::AddDataSourceL() out")));

    }

// -----------------------------------------------------------------------------

// CCamCController::AddDataSinkL

// Add data sink to controller.

// (other items were commented in a header).

//

void CCamCController::AddDataSinkL(MDataSink& aDataSink)

    {

    PRINT((_L("CCamCController::AddDataSinkL() in")));

    if( iState != EStateNone )

        {

        User::Leave( KErrNotReady );

        }

    if (aDataSink.DataSinkType()==KUidMmfFileSink)

        {

        iMMFFile = STATIC_CAST(CMMFFile*, &aDataSink);

        iFileName = iMMFFile->FullName();

        iForceDataSinkFileName = EFalse;

        if (!iFileComposer)

            {

            iFileComposer = CCamC3GPDataSink::NewL(this);

            }

        if ( ReadyToOpenSource() )

            {

            OpenSourceL();

            }

        }

    else

        {

        User::Leave(KErrNotSupported);

        }

    PRINT((_L("CCamCController::AddDataSinkL() out")));

    }

// -----------------------------------------------------------------------------

// CCamCController::RemoveDataSourceL

// Remove data source from controller.

// (other items were commented in a header).

//

void CCamCController::RemoveDataSourceL(MDataSource& /*aDataSource*/)

    {

    // Not called from Video Recorder client API

    PRINT((_L("CCamCController::RemoveDataSourceL() Not Supported - leaving")));

    User::Leave( KErrNotSupported );

    }

// -----------------------------------------------------------------------------

// CCamCController::RemoveDataSinkL

// Remove data sink from controller.

// (other items were commented in a header).

//

void CCamCController::RemoveDataSinkL(MDataSink& /*aDataSink*/)

    {

    // Not called from Video Recorder client API

    PRINT((_L("CCamCController::RemoveDataSinkL() Not Supported - leaving")));

    User::Leave( KErrNotSupported );

    }

// -----------------------------------------------------------------------------

// CCamCController::ResetL

// Reset controller

// (other items were commented in a header).

//

void CCamCController::ResetL()

    {

    // Not called from Video Recorder client API

    PRINT((_L("CCamCController::ResetL() Not Supported - leaving")));

    User::Leave( KErrNotSupported );

    }

// -----------------------------------------------------------------------------

// CCamCController::PrimeL

// Primes controller.

// (other items were commented in a header).

//

void CCamCController::PrimeL()

    {

    // Preparing to record is handled by MvrcPrepareL

    }

// -----------------------------------------------------------------------------

// CCamCController::PlayL

// Start recording.

// (other items were commented in a header).

//

void CCamCController::PlayL()

    {

    PRINT((_L("CCamCController::PlayL() in")));

    if ( iState == EStateRecording )

        {

        return;

        }

    if ( ( iState != EStatePrepared ) && ( iState != EStatePaused ) )

        {

        User::Leave(KErrNotReady);

        }

    iSavedStopError = KErrNone;

    if ( iState == EStatePrepared )

        {

        if ( iFileComposerReady == EFalse ) // to handle record, stop, record (without prepare)

            {

            if ( iMediaRecorder->AudioEnabledL() )

                {

                iMediaRecorder->GetAudioCodecL(iAudioCodec);

                }

            else

                {

                iAudioCodec = KFourCCNULL;

                }

            TInt error = KErrNone;

            if( iForceDataSinkFileName )

                {

                TRAP( error, iFileComposer->OpenFileL( iFileName, iAudioCodec, *iVideoCodec, iVideoFormat ) );

                }

            else

                {

                TRAP( error, iFileComposer->OpenFileL( iMMFFile, iAudioCodec, *iVideoCodec, iVideoFormat ) );

                }

            if ( error != KErrNone )

                {

                DoSendEventToClient(TMMFEvent(KMMFEventCategoryPlaybackComplete, error));

                return;

                }

            else

                {

                iFileComposerReady = ETrue;

                }

            }

        iMediaRecorder->RecordL();

        }

    else

        {

        iMediaRecorder->ResumeL();

        }

    iState = EStateRecording;

    PRINT((_L("CCamCController::PlayL() out")));

    }

// -----------------------------------------------------------------------------

// CCamCController::PauseL

// Pause recording.

// (other items were commented in a header).

//

void CCamCController::PauseL()

    {

    PRINT((_L("CCamCController::PauseL() in")));

    if ( iState != EStateRecording )

        {

        User::Leave(KErrNotReady);

        }

    iMediaRecorder->PauseL();

    iState = EStatePaused;

    PRINT((_L("CCamCController::PauseL() out")));

    }

// -----------------------------------------------------------------------------

// CCamCController::StopL

// Stop recording.

// (other items were commented in a header).

//

void CCamCController::StopL()

    {

    PRINT((_L("CCamCController::StopL() in")));

    if ( ( iState != EStateRecording ) && ( iState != EStatePaused ) )

        {

        PRINT((_L("CCamCController::StopL() out - not recording")));

        if ( iSavedStopError != KErrNone )

            {

            User::Leave( iSavedStopError );

            }

        else

            {

            return;

            }

        }

    iState = EStateStopping;

    TInt error = KErrNone;

    TRAP( error, iMediaRecorder->StopL() );

    if ( error != KErrNone )

        {

        PRINT((_L("CCamCController::StopL() MediaRecorderStop error= %d      "), error));

        iState = EStatePrepared;

        iFileComposerReady = EFalse;

        TRAPD( ignored, iFileComposer->SinkStopL() );

        ignored++; // to remove compile warning. There has already been error, further errors are ignored.

        if ( !iAsyncStop )

	        {

    	    User::Leave( error );

        	}

        }

    PRINT((_L("CCamCController::StopL() iAsyncStop=%d      "), iAsyncStop));

	if ( iAsyncStop )

		{

        PRINT((_L("CCamCController::StopL() sending event KCamCControllerCCVideoStoppedUid, error=%d      "), error));

		DoSendEventToClient(TMMFEvent(KCamCControllerCCVideoRecordStopped, error));

        if ( !iIdleStop->IsActive() )

            {

            iIdleStop->Start( TCallBack( IdleStop, this ) );

            }

		}

    else // Sync stop

        {

        error = KErrNone;

        TRAP( error, iFileComposer->SinkStopL() );

        if ( error != KErrNone )

            {

            PRINT((_L("CCamCController::StopL() FileComposerStop error= %d      "), error));

            iState = EStatePrepared;

            iFileComposerReady = EFalse;

      	    User::Leave( error );

            }

    	if ( (iSavedStopError == KErrDiskFull) || (iSavedStopError == KErrCompletion ) || (iSavedStopError == KErrNone) )

	    	{

    	    iState = EStatePrepared;

    		}

	    else

		    {

    		// Fatal error happened, need to prepare again.

	    	iState = EStateOpen;

		    }

        iFileComposerReady = EFalse;

        }

    PRINT((_L("CCamCController::StopL() out")));

    }

// -----------------------------------------------------------------------------

// CCamCController::PositionL

// Returns current recording position.

// (other items were commented in a header).

//

TTimeIntervalMicroSeconds CCamCController::PositionL() const

    {

     // Not called from Video Recorder client API

    return TTimeIntervalMicroSeconds(0);

    }

// -----------------------------------------------------------------------------

// CCamCController::SetPositionL

// Not supported.

// (other items were commented in a header).

//

void CCamCController::SetPositionL(const TTimeIntervalMicroSeconds& /*aPosition*/)

    {

    User::Leave(KErrNotSupported);

    }

// -----------------------------------------------------------------------------

// CCamCController::DurationL

// Current duration of recording.

// (other items were commented in a header).

//

TTimeIntervalMicroSeconds CCamCController::DurationL() const

    {

    if ( iFileComposer )

        {

        return iFileComposer->GetElapsedTime();

        }

    else

        {

        return TTimeIntervalMicroSeconds(0);

        }

    }

// -----------------------------------------------------------------------------

// CCamCController::SetPrioritySettings

// Set camcorder priority settings.

// (other items were commented in a header).

//

void CCamCController::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

    {

    PRINT((_L("CCamCController::SetPrioritySettings() in")));

    TInt error = KErrNone;

    iPrioritySettings = aPrioritySettings;

    if ( iState == EStatePrepared )

        {

            iState = EStateOpen;

        }

    if ( iMediaRecorder )

        {

        if ( iState != EStateOpen )

            {

            error = KErrNotReady;

            }

        else

            {

            TRAP(error, iMediaRecorder->SetAudioPriorityL( iPrioritySettings ));

            }

        }

    if ( error != KErrNone )

        {

        DoSendEventToClient(TMMFEvent(KMMFEventCategoryVideoRecorderGeneralError, error));

        }

    PRINT((_L("CCamCController::SetPrioritySettings() out")));

    }

// -----------------------------------------------------------------------------

// CCamCController::CustomCommand

// Handle custom commands to controller.

// (other items were commented in a header).

//

void CCamCController::CustomCommand( TMMFMessage& aMessage )

    {

    PRINT((_L("CCamCController::CustomCommand() in")));

    if ( aMessage.Destination().InterfaceId().iUid != KCamCUidControllerImplementation )

        {

        aMessage.Complete(KErrNotSupported);

        PRINT((_L("CCamCController::CustomCommand() KErrNotSupported out")));

        return;

        }

    TInt error = KErrNone;

    switch ( aMessage.Function() )

        {

        case ECamCControllerCCNewFilename:

            {

            PRINT((_L("CCamCController::CustomCommand() ECamCControllerCCNewFilename")));

            TRAP( error, NewFilenameL( aMessage ) );

            aMessage.Complete(error);

            break;

            }