/*

* Copyright (c) 2007-2008 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:  Provides implementation for CCallInformation -class.

*

*/

#include <e32base.h>

#include <callinformation.h>    //Call Information Mediator API

#include "ccallinformationimpl.h"

#include "ccallinfoiter.h"

#include "mcallinformationobserver.h"

#include "telsrvlogger.h"

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

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

// C++ constructor.

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

//

CCallInformationImpl::CCallInformationImpl() : CTelSrvBase( )

    {

    }

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

// Symbian second-phase constructor.

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

//

void CCallInformationImpl::ConstructL(CMediatorService* aMediatorService)

    {    

    CTelSrvBase::BaseConstructL( aMediatorService );    

    }

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

// Two-phased constructor.

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

//

CCallInformationImpl* CCallInformationImpl::NewL()

    {

    TSLOGSTRING("CCallInformationImpl::NewL <<");

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

    CleanupStack::PushL( self );

    CMediatorService* mediatorService = CMediatorService::NewLC( CMediatorService::ECallInfo );    

    self->ConstructL(mediatorService);    

    CleanupStack::Pop( 2,self );    

    TSLOGSTRING("CCallInformationImpl::NewL >>");

    return self;

    }

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

// Two-phased constructor for testing purposes.

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

//

CCallInformationImpl* CCallInformationImpl::NewL(CMediatorService* aMediatorService)

    {        

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

    CleanupStack::PushL( self );

    self->ConstructL(aMediatorService);

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CCallInformationImpl::~CCallInformationImpl()

    {        

    delete iInfos;

    delete iCallIter;       

    delete iInfosInState;    

    delete iCallStateIter;    

    }

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

// Saves the observer call information changes.

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

//

void CCallInformationImpl::NotifyCallInformationChanges(

    MCallInformationObserver& aObserver )

    {

    TSLOGSTRING("CCallInformationImpl::NotifyCallInformationChanges <<");

    iObserver = &aObserver;    

    }

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

// Removes the observer.

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

//

void CCallInformationImpl::CancelNotification( )

    {

    TSLOGSTRING("CCallInformationImpl::CancelNotification <<");

    iObserver = NULL;    

    }

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

// From class CTelSrvBase.

// A response to a Mediator Service command.

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

//

void CCallInformationImpl::DoHandleCommandResponseL( const TDesC8& aData )

  {

  TSLOGSTRING("CCallInformationImpl::DoHandleCommandResponseL <<");  

  iInfos = CCallInfos::NewL();

  iInfos->InternalizeL( aData );                

  iCallIter = CCallInfoIter::NewL( *iInfos );

  TSLOGSTRING("CCallInformationImpl::DoHandleCommandResponseL >>");

  }

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

// From class MMediatorServiceObserver

// A Mediator Service event.

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

//

void CCallInformationImpl::DoHandleMediatorEventL( const TDesC8& aData )

  {  

  TSLOGSTRING("CCallInformationImpl::DoHandleMediatorEventL <<");  

  delete iInfos;

  iInfos = NULL;

  delete iCallIter;

  iCallIter = NULL;

  iInfos = CCallInfos::NewL();

  iInfos->InternalizeL( aData );      

  iCallIter = CCallInfoIter::NewL( *iInfos );      

  if( iObserver )

      {

      iObserver->CallInformationChanged();

      }  

  TSLOGSTRING("CCallInformationImpl::DoHandleMediatorEventL >>");

  }

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

// Returns info about all calls. 

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

//

CCallInfoIter& CCallInformationImpl::GetCallsL( )

    {    

    TSLOGSTRING("CCallInformationImpl::GetCallsL <<");

    if( !iCallIter )

        {

        TSLOGSTRING("CCallInformationImpl::GetCallsL; Leaves with KErrNoMemory");

        User::Leave( KErrNoMemory ); //memory allocation failed in CommandResponseL or MediatorEventL

        }

    TSLOGSTRING("CCallInformationImpl::GetCallsL >>");

    return *iCallIter;            

    }

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

// Returns information whether call in given state exist. 

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

//

TBool CCallInformationImpl::IsCallInState( CCPCall::TCallState aState ) const

    {

    TBool match ( EFalse );

    const RPointerArray<TCallInfo>& calls = iInfos->CallInfos();

    TInt count = calls.Count();

    for( int i = 0; i < count; i++ )

        {

        const TCallInfo& call = *calls[i];

        if( aState == call.CallState() )    

            {

            match = ETrue;

            break;

            }

        }           

    return match;

    }