/*

* Copyright (c) 2002-2004 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:    Mcc EventHandler

*

*/

// INCLUDE FILES

#include "mmccevent.h"

#include "mmccinterface.h"

#include "mmccevents.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CMccEvent::CMccEvent

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMccEvent::CMccEvent( RMMFController& aController, MMccCtrlObserver& aCallback )

    : CActive( EPriorityStandard ),

      iController( aController ), 

      iEventCallBack( aCallback ),

      iMessageDest( KMccControllerUidInterface )

    {

    CActiveScheduler::Add( this );

    }

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

// CMccEvent::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccEvent::ConstructL()

    {

    }

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

// CMccEvent::NewL

// Static constructor.

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

//

CMccEvent* CMccEvent::NewL( RMMFController& aController, 

                            MMccCtrlObserver& aObserver )

    {

    CMccEvent* self = new (ELeave) CMccEvent( aController, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccEvent::~CMccEvent

// Destructor

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

//

CMccEvent::~CMccEvent()

    {

    if( IsActive() )

        {

        Cancel();

        }

    }

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

// CMccEvent::RequestEventNotification

// Requests for event from Controller plugin and starts event listening loop.

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

//

void CMccEvent::RequestEventNotification()

    {

    if ( !IsActive() )

        {

        iController.CustomCommandAsync( iMessageDest,

                                        ERequestEventNotification,

                                        KNullDesC8,

                                        KNullDesC8,

                                        iPackage,

                                        iStatus);

        SetActive();

        }

    else

        {

        // Something is very wrong here

        }

    }

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

// CMccEvent::DoCancel

// From CActive Implements cancellation of an outstanding request.

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

//

void CMccEvent::DoCancel()

    {

    iController.CustomCommandSync( iMessageDest, EMccCancel, 

                                    KNullDesC8, KNullDesC8 );

    }

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

// CMccEvent::RunL

// From CActive Handles an active object’s request completion event.

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

//

void CMccEvent::RunL()

    {

    if ( KErrNone == iStatus.Int() )

        {

        TMccEvent event = iPackage();

        switch( event.iEventType )

            {

            //HandleMccMediaEvent

            case KMccRtcpReceived:

            case KMccDtmfReceived:

            case KMccDtmfControl:

            case KMccStreamPlaying:

            case KMccStreamBuffering:

            case KMccStreamIdle:

            case KMccLinkCreated:

            case KMccMediaQualityStatus:

            case KMccResourceNotAvailable:

            case KMccTranscodeCancelled:

            case KMccTranscodeInProgress:

            case KMccTranscodeCompleted:

            case KMccMasterKeyStaled:

                HandleMccMediaEvent( event );

                break;

            //HandleMccErrorEvent

            case KMccStreamError:

            case KMccStreamMMFEvent:

                HandleMccErrorEvent( event );

                break;

            //HandleMccStateChangeEvent

            case KMccStreamPrepared:

            case KMccStreamStarted:

            case KMccStreamPaused:

            case KMccStreamResumed:

            case KMccStreamStopped:

            case KMccStreamClosed:

                HandleMccStateChangeEvent( event );

                break;

            //HandleMccInactivityEvent

            case KMccInactivityEvent:

                HandleMccInactivityEvent( event );

                break;

            //HandleMccActivityEvent

            case KMccActivityEvent:

                HandleMccActivityEvent( event );

                break;

            case KMccUnknownMediaReceived:

                HandleMccUnknownMediaEvent( event );

                break;    

            default:

                break;

            }

        RequestEventNotification();

        }

    else

        {

        User::Leave( iStatus.Int() );

        }        

    }

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

// CMccEvent::RunError

// From CActive Handles 

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

//

TInt CMccEvent::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    }

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

// CMccEvent::HandleMccMediaEvent

// 

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

//

void CMccEvent::HandleMccMediaEvent( const TMccEvent& aEvent )

    {

    iEventCallBack.MccEventReceived( aEvent );

    }

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

// CMccEvent::HandleMccStateChangeEvent

// 

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

//

void CMccEvent::HandleMccStateChangeEvent( const TMccEvent& aEvent )

    {

    if ( aEvent.iErrorCode )

        {

        HandleMccErrorEvent( aEvent );

        return;

        }

    switch ( aEvent.iEventType )

        {

        case KMccStreamPrepared:

            iEventCallBack.MccMediaPrepared( aEvent.iSessionId, aEvent.iLinkId,

                                           aEvent.iStreamId, aEvent.iEndpointId );

            break;

        case KMccStreamStarted:

            iEventCallBack.MccMediaStarted( aEvent.iSessionId, aEvent.iLinkId,

                                          aEvent.iStreamId, aEvent.iEndpointId );

            break;        

        case KMccStreamPaused:

            iEventCallBack.MccMediaPaused( aEvent.iSessionId, aEvent.iLinkId,

                                         aEvent.iStreamId, aEvent.iEndpointId );

            break;        

        case KMccStreamResumed:

            iEventCallBack.MccMediaResumed( aEvent.iSessionId, aEvent.iLinkId,

                                          aEvent.iStreamId, aEvent.iEndpointId );

            break;        

        case KMccStreamStopped:

            iEventCallBack.MccMediaStopped( aEvent.iSessionId, aEvent.iLinkId,

                                          aEvent.iStreamId, aEvent.iEndpointId );

            break;        

        default:

            break;

        }

    }

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

// CMccEvent::HandleMccInactivityEvent

// 

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

//

void CMccEvent::HandleMccInactivityEvent( const TMccEvent& aEvent )

    {

    iEventCallBack.MccMediaInactive( aEvent.iSessionId,

                                   aEvent.iLinkId,

                                   aEvent.iStreamId,

                                   aEvent.iEndpointId );

    }

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

// CMccEvent::HandleMccActivityEvent

// 

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

//

void CMccEvent::HandleMccActivityEvent( const TMccEvent& aEvent )

    {

    iEventCallBack.MccMediaActive( aEvent.iSessionId,

                                 aEvent.iLinkId,

                                 aEvent.iStreamId,

                                 aEvent.iEndpointId );

    }

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

// CMccEvent::HandleMccErrorEvent

// 

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

//

void CMccEvent::HandleMccErrorEvent( const TMccEvent& aEvent )

    {

    iEventCallBack.MccCtrlError( aEvent.iErrorCode, 

                                 aEvent.iSessionId, 

    	                         aEvent.iLinkId, 

    	                         aEvent.iStreamId, 

    	                         aEvent.iEndpointId );

    }

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

// CMccEvent::HandleMccUnknownMediaEvent

// 

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

//

void CMccEvent::HandleMccUnknownMediaEvent( const TMccEvent& aEvent )

    {

    iEventCallBack.UnknownMediaReceived( aEvent.iSessionId, aEvent.iLinkId, 

        aEvent.iStreamId, aEvent.iEndpointId, TUint8( aEvent.iErrorCode ) );

    }