/*

* Copyright (c) 2006 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:    

*

*/

// INCLUDE FILES

#include "mccvideosourcekeyretriever.h"

#include "mccinternalcodecs.h"

#include "mccinternaldef.h"

#include "mccinternalevents.h"

#include "mccvideosourceimpl.h"

#include "mccvideosourcesinklogs.h"

#include "mccperiodicrunner.h"

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

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

// CMccVideoSourceConfigKeyRetriever::NewLC

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

//

CMccVideoSourceConfigKeyRetriever* CMccVideoSourceConfigKeyRetriever::NewLC( 

    MMccCameraHandler& aCameraHandler )

    {

    CMccVideoSourceConfigKeyRetriever* self = 

        new ( ELeave ) CMccVideoSourceConfigKeyRetriever( aCameraHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CMccVideoSourceConfigKeyRetriever::~CMccVideoSourceConfigKeyRetriever

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

//    

CMccVideoSourceConfigKeyRetriever::~CMccVideoSourceConfigKeyRetriever()

    {

    __V_SOURCESINK_CONTROLL( 

    "CMccVideoSourceConfigKeyRetriever::~CMccVideoSourceConfigKeyRetriever" )

    delete iGuardTimer;

    StopWaiting();

    delete iWait;

    delete iSource;

    delete iBuffer;

    __V_SOURCESINK_CONTROLL( 

    "CMccVideoSourceConfigKeyRetriever::~CMccVideoSourceConfigKeyRetriever, exit" )

    }

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

// CMccVideoSourceConfigKeyRetriever::RetrieveL

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

//    

void CMccVideoSourceConfigKeyRetriever::RetrieveL( 

    const TMccCodecInfo& aVideoCodec, 

    TDes8& aConfigKey )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::RetrieveL" )

    __ASSERT_ALWAYS( aVideoCodec.iSdpName.CompareF( KAVCSdpName ) == 0, 

                     User::Leave( KErrNotSupported ) );

    delete iBuffer;

    iBuffer = NULL;

    iBuffer = CMMFDataBuffer::NewL( aVideoCodec.iFrameSize );

    delete iSource;

    iSource = NULL;

    iSource = CMccVideoSourceImpl::NewL( 0, NULL, ETrue );

    iFailed = EFalse;

    iSource->SourceThreadLogon( *this );

    iSource->SetCameraHandler( iCameraHandler );

    iSource->SetVideoCodecL( aVideoCodec );

    iSource->SourcePrimeL( EFalse );

    if ( !iSource->HasConfigKey() && !iFailed )

        {

        __V_SOURCESINK_CONTROLL( "Start waiting for key" )

        // Start also guard timer to prevent possible eternal jam

        StartGuardTimer();

        iWait->Start();

        __V_SOURCESINK_CONTROLL( "Waiting completed" )

        StopGuardTimer();

        }

    __ASSERT_ALWAYS( !iFailed, User::Leave( KErrNotFound ) );

    iSource->GetConfigKeyL( aVideoCodec, aConfigKey, EFalse );

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::RetrieveL, exit" )

    }

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

// CMccVideoSourceConfigKeyRetriever::SendEventToClient

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

//           

TInt CMccVideoSourceConfigKeyRetriever::SendEventToClient( const TMMFEvent& aEvent )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::SendEventToClient" )

    TInt error( KErrNone );

   	TMccEvent* mccEventPtr = NULL;

	if ( IS_MCC_EVENT( aEvent ) )

	    {

	    mccEventPtr = 

	        reinterpret_cast<const TMccInternalEvent&>( aEvent ).iMccEvent;                                     

	    }

	if ( mccEventPtr )

	    {

	    TRAP( error, HandleEventL( *mccEventPtr ) );

	    if ( error != KErrNone )

	        {

	        HandleError();

	        }

	    }

	__V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::SendEventToClient, exit" )    

	return error;

    }

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

// CMccVideoSourceConfigKeyRetriever::SinkDataTypeCode

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

//    

TFourCC CMccVideoSourceConfigKeyRetriever::SinkDataTypeCode( TMediaId /*aMediaId*/ )

    {

    return TFourCC( 0 );

    }

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

// CMccVideoSourceConfigKeyRetriever::EmptyBufferL

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

//    

void CMccVideoSourceConfigKeyRetriever::EmptyBufferL( 

    CMMFBuffer* /*aBuffer*/, MDataSource* /*aSupplier*/, TMediaId /*aMediaId*/ )

    {

    }

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

// CMccVideoSourceConfigKeyRetriever::BufferFilledL

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

//    

void CMccVideoSourceConfigKeyRetriever::BufferFilledL( CMMFBuffer* /*aBuffer*/ )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::BufferFilledL" )

    // First buffer was received from mediarecorder, config info should be now

    // available.

    StopWaiting();

    }

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

// CMccVideoSourceConfigKeyRetriever::CanCreateSinkBuffer

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

//    

TBool CMccVideoSourceConfigKeyRetriever::CanCreateSinkBuffer()

    {

    return EFalse;

    }

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

// CMccVideoSourceConfigKeyRetriever::CreateSinkBufferL

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

//    

CMMFBuffer* CMccVideoSourceConfigKeyRetriever::CreateSinkBufferL(

    TMediaId /*aMediaId*/, TBool& /*aReference*/ )

    {

    return NULL;

    }

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

// CMccVideoSourceConfigKeyRetriever::ConstructSinkL

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

//    

void CMccVideoSourceConfigKeyRetriever::ConstructSinkL( const TDesC8& /*aInitData*/ )

    {

    }

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

// CMccVideoSourceConfigKeyRetriever::ConstructL

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

//

void CMccVideoSourceConfigKeyRetriever::ConstructL()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::ConstructL" )

    iWait = new ( ELeave ) CActiveSchedulerWait;

    iGuardTimer = CMccPeriodicRunner::NewL();

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::ConstructL, exit" )

    }

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

// CMccVideoSourceConfigKeyRetriever::ConstructL

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

//    

CMccVideoSourceConfigKeyRetriever::CMccVideoSourceConfigKeyRetriever( 

    MMccCameraHandler& aCameraHandler ) :

    MDataSink( KNullUid ),

    iCameraHandler( aCameraHandler ),

    iGuardTimerTimeout( KMccKeyRetrieveGuardTimeoutMicrosecs )

    {

    }

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

// CMccVideoSourceConfigKeyRetriever::HandleEventL

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

//

void CMccVideoSourceConfigKeyRetriever::HandleEventL( TMccEvent& aEvent )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::HandleEventL" )

    if ( aEvent.iEventType == KMccStreamError || aEvent.iErrorCode != KErrNone )

        {

        User::Leave( KErrNotReady );

        }

    else if ( aEvent.iEventType == KMccStreamPrepared )

        {

        __V_SOURCESINK_CONTROLL( "Prepared" )

        // Start recording, first buffer received from mediarecorder

	    // should contain config info         

        iSource->FillBufferL( iBuffer, this, KUidMediaTypeVideo );

	    iSource->SourcePlayL();

        }

    else if ( aEvent.iEventType == KMccStreamStarted )

        {

        __V_SOURCESINK_CONTROLL( "Started" )

        }

    else

        {

        // NOP

        }

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::HandleEventL, exit" )

    }

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

// CMccVideoSourceConfigKeyRetriever::HandleError

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

//    

void CMccVideoSourceConfigKeyRetriever::HandleError()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::HandleError" )

    iFailed = ETrue;

    StopWaiting();

    }

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

// CMccVideoSourceConfigKeyRetriever::StopWaiting

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

//

void CMccVideoSourceConfigKeyRetriever::StopWaiting()

    {

    if ( iWait && iWait->IsStarted() )

        {

        __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::StopWaiting" )

        iWait->AsyncStop();

        }

    }

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

// CMccVideoSourceConfigKeyRetriever::StartGuardTimer

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

//

void CMccVideoSourceConfigKeyRetriever::StartGuardTimer()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::StartGuardTimer" )

    iGuardTimer->Start( 

        iGuardTimerTimeout, TCallBack( GuardTimerExpired, this ) );	

    }

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

// CMccVideoSourceConfigKeyRetriever::StopGuardTimer

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

//

void CMccVideoSourceConfigKeyRetriever::StopGuardTimer()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::StopGuardTimer" )

    iGuardTimer->Stop();	

    }

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

// CMccVideoSourceConfigKeyRetriever::GuardTimerExpired

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

//

TInt CMccVideoSourceConfigKeyRetriever::GuardTimerExpired( TAny* aObject )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::GuardTimerExpired" )

    CMccVideoSourceConfigKeyRetriever* self = 

        static_cast<CMccVideoSourceConfigKeyRetriever*>( aObject );

    if ( self )

        {

        self->StopWaiting();

        }

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceConfigKeyRetriever::GuardTimerExpired, exit" )

    return KErrNone;

    }

// End of file