/*
* 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:  Asynchronises cce call observer calls 
*
*/


//  INCLUDE FILES

#include "cccecallobserverasynchroniser.h"
#include "cccelogger.h"

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

// -----------------------------------------------------------------------------
// NewL()
// Two-phased constructor
// -----------------------------------------------------------------------------

CCCECallObserverAsynchroniser* CCCECallObserverAsynchroniser::NewL()
    {
    CCCECallObserverAsynchroniser* self = CCCECallObserverAsynchroniser::NewLC();
    CleanupStack::Pop( self );
    return self; 
    }

// -----------------------------------------------------------------------------
// NewLC()
// Two-phased constructor
// Leaves pointer in cleanup stack
// -----------------------------------------------------------------------------

CCCECallObserverAsynchroniser* CCCECallObserverAsynchroniser::NewLC()
    {
    CCCECallObserverAsynchroniser* self = new( ELeave ) CCCECallObserverAsynchroniser();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;    
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
CCCECallObserverAsynchroniser::~CCCECallObserverAsynchroniser()
    {
    Cancel();
    iEvents.Close();  
    }

// -----------------------------------------------------------------------------
// Set call observer
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::SetMCCECallObserver( MCCECallObserver* aObserver )
    {
    CCELOGSTRING( "CCCECallObserverAsynchroniser::SetMCCECallObserver()" );
    iCCECallObserver = aObserver;
    if ( iIsRuning && aObserver )
        {
        if( !IsActive() )
            {
            SetActive();
            TRequestStatus* status = &iStatus;
            User::RequestComplete( status, KErrNone );
            }
        }
     else
        {
        Cancel();
        iEvents.Reset();
        }
    }

// -----------------------------------------------------------------------------
// get call observer
// -----------------------------------------------------------------------------    
MCCECallObserver* CCCECallObserverAsynchroniser::GetMCCECallObserver()
    {
    return iCCECallObserver;
    }

// -----------------------------------------------------------------------------
// CActive RunL
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::RunL()
    {
    CCELOGSTRING2( "CCCECallObserverAsynchroniser::RunL() events: %d", iEvents.Count() );
 
    if ( !iCCECallObserver )
        {
        CCELOGSTRING( "CCCECallObserverAsynchroniser::RunL() No observer!");
        return;
        }
        
    while (iEvents.Count() > 0)
        {
        switch ( iEvents[0].iEventType )
            {
            case EErrorOccurred:
                {
                CCELOGSTRING( "CCCECallObserverAsynchroniser::RunL() Event: EErrorOccurred");
                iCCECallObserver->ErrorOccurred(
                    (TCCPError)iEvents[0].iInt1 );
                break;    
                }           
            
            case ECallStateChanged:
                {
                CCELOGSTRING( "CCCECallObserverAsynchroniser::RunL() Event: ECallStateChanged");
                iCCECallObserver->CallStateChanged(
                    (CCPCall::TCallState)iEvents[0].iInt1 );
                break;    
                }
                
            case ECallStateChangedWithInband:
                {
                CCELOGSTRING( "CCCECallObserverAsynchroniser::RunL() Event: ECallStateChangedWithInband");
                iCCECallObserver->CallStateChangedWithInband(
                    (CCPCall::TCallState)iEvents[0].iInt1 );
                break;    
                }
                
            case ECallEventOccurred:
                {
                CCELOGSTRING( "CCCECallObserverAsynchroniser::RunL() Event: ECallEventOccurredanged");
                iCCECallObserver->CallEventOccurred(
                    (MCCECallObserver::TCCECallEvent)iEvents[0].iInt1 );
                break;    
                }
                
            case ECallDurationChanged:
                {
                CCELOGSTRING( "CCCECallObserverAsynchroniser::RunL() Event: ECallDurationChanged");
                iCCECallObserver->CallDurationChanged(iEvents[0].iDuration );
                break;    
                }
                
            case ECallCapsChanged:
                {
                CCELOGSTRING( "CCCECallObserverAsynchroniser::RunL() Event: ECallCapsChanged");
                iCCECallObserver->CallCapsChanged(
                    (MCCECallObserver::TCCECallControlCaps)iEvents[0].iInt1 );
                break;    
                }
                
            case EHandleTransfer:
                {
                CCELOGSTRING( "CCCECallObserverAsynchroniser::RunL() Event: EHandleTransfer");
                iCCECallObserver->HandleTransfer(iEvents[0].iBoolean, *iEvents[0].iDescriptor );
                break;    
                }
            }
            
        if( iEvents.Count() )
            {
            iEvents.Remove( 0 );
            iEvents.Compress();
            }
        }
    
    iIsRuning = EFalse;
    }

// -----------------------------------------------------------------------------
// CActive RunError
// -----------------------------------------------------------------------------
TInt CCCECallObserverAsynchroniser::RunError(TInt aError)
    {
    return aError;
    }

// -----------------------------------------------------------------------------
// CActive DoCancel
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::DoCancel()   
    {
    iEvents.Reset();
    iIsRuning = EFalse;
    }

// -----------------------------------------------------------------------------
// MCCECallObserver ErrorOccurred
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::ErrorOccurred( const TCCPError aError )
    {
    CCELOGSTRING( "CCCECallObserverAsynchroniser::ErrorOccurred");
    TEventStorage event;
    event.iEventType = EErrorOccurred;
    event.iInt1 = aError;
    AddEvent(event);
        
    }

// -----------------------------------------------------------------------------
// MCCECallObserver CallStateChanged
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::CallStateChanged(
    const CCPCall::TCallState aState )
    {
    CCELOGSTRING( "CCCECallObserverAsynchroniser::CallStateChanged");
    TEventStorage event;
    event.iEventType = ECallStateChanged;
    event.iInt1 = aState;
    AddEvent(event);
        
    }

// -----------------------------------------------------------------------------
// MCCECallObserver CallStateChangedWithInband
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::CallStateChangedWithInband(
    const CCPCall::TCallState aState )
    {
    CCELOGSTRING( "CCCECallObserverAsynchroniser::CallStateChangedWithInband");
    TEventStorage event;
    event.iEventType = ECallStateChangedWithInband;
    event.iInt1 = aState;
    AddEvent(event);
        
    }

// -----------------------------------------------------------------------------
// MCCECallObserver CallEventOccurred
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::CallEventOccurred( 
    const MCCECallObserver::TCCECallEvent aEvent )
    {
    CCELOGSTRING( "CCCECallObserverAsynchroniser::CallEventOccurred");
    TEventStorage event;
    event.iEventType = ECallEventOccurred;
    event.iInt1 = aEvent;
    AddEvent(event);
        
    }

// -----------------------------------------------------------------------------
// MCCECallObserver CallDurationChanged
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::CallDurationChanged( 
    const TTimeIntervalSeconds aDuration )
    {
    CCELOGSTRING( "CCCECallObserverAsynchroniser::CallDurationChanged");
    TEventStorage event;
    event.iEventType = ECallDurationChanged;
    event.iDuration = aDuration;
    AddEvent(event);
    }

// -----------------------------------------------------------------------------
// MCCECallObserver CallCapsChanged
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::CallCapsChanged( 
    const MCCECallObserver::TCCECallControlCaps aCaps )
    {
    CCELOGSTRING( "CCCECallObserverAsynchroniser::CallCapsChanged");
    TEventStorage event;
    event.iEventType = ECallCapsChanged;
    event.iInt1 = aCaps;
    AddEvent(event);
    }

// -----------------------------------------------------------------------------
// MCCECallObserver HandleTransfer
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::HandleTransfer( const TBool aAttended, 
                             const TDesC& aDestination )
    {
    CCELOGSTRING( "CCCECallObserverAsynchroniser::HandleTransfer");
    TEventStorage event;
    event.iEventType = EHandleTransfer;
    event.iBoolean = aAttended;
    event.iDescriptor = &aDestination;
    AddEvent(event);
    }

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
CCCECallObserverAsynchroniser::CCCECallObserverAsynchroniser() 
    :CActive( EPriorityStandard ), iIsRuning( EFalse )
    { 
    }


// -----------------------------------------------------------------------------
// Leaving stuff in constructor
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::ConstructL()
    {
    CActiveScheduler::Add( this );
    }
    
// -----------------------------------------------------------------------------
// Adding event to queue
// -----------------------------------------------------------------------------
void CCCECallObserverAsynchroniser::AddEvent( TEventStorage aEvent )
    {
    iEvents.Append(aEvent);
    CCELOGSTRING( "CCCECallObserverAsynchroniser::AddEvent");
    if (!iIsRuning)
        {
        CCELOGSTRING( "CCCECallObserverAsynchroniser::AddEvent Activating...");
        iIsRuning = ETrue;
        if (iCCECallObserver)
            {
            SetActive();
            TRequestStatus* status = &iStatus;
            User::RequestComplete(status, KErrNone);    
            }
        }
    }
// end of file