/*

* Copyright (c) 2009 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:  Updates remote party information via mediator.

*

*/

#include "tperemotepartyinfomediatorupdater.h"

#include "mpemediator.h"

#include "mpedatastore.h"

#include <talogger.h>

#include <MediatorDomainUIDs.h>

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

// C++ constructor

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

//

TPERemotePartyInfoMediatorUpdater::TPERemotePartyInfoMediatorUpdater(

    MPEMediator& aMediator,

    MPEDataStore& aDataStore ) 

    : iMediator( aMediator ),

    iDataStore( aDataStore )

    {

    }

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

// Sends mediator event with remote info.

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

//

void TPERemotePartyInfoMediatorUpdater::Update()

    {

    HBufC8* data = NULL;

    TRAPD( err, data = TakeSnapshotOfRemotePartyInfosL() );

    if ( !err )

        {

        iMediator.RaiseEvent( 

                KCatCallRemotePartyInformation,

                EChangesInRemotePartyInformation,

                *data );

        }

    delete data;

    }

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

// From base class MMediatorCommandObserver

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

//

void TPERemotePartyInfoMediatorUpdater::MediatorCommandL( 

    TUid aDomain,

    TUid aCategory, 

    TInt aCommandId,

    TVersion /*aVersion*/, 

    const TDesC8& /*aData*/ )

    {

    if ( aDomain == KMediatorTelephonyDomain &&

         aCategory == KCatCallRemotePartyInformation &&

         aCommandId == EGetCallRemotePartyInformation )

        {

        HBufC8* data = TakeSnapshotOfRemotePartyInfosL();

        iMediator.SendResponse( 

            KCatCallRemotePartyInformation,

            EGetCallRemotePartyInformation,

            *data );

        delete data;

        }

    }

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

// From base class MMediatorCommandObserver

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

//

void TPERemotePartyInfoMediatorUpdater::CancelMediatorCommand( 

    TUid /*aDomain*/,

    TUid /*aCategory*/, 

    TInt /*aCommandId*/ )

    {

    }

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

// Takes remote party information from all calls and packs them to 

// descriptor.

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

//

HBufC8* TPERemotePartyInfoMediatorUpdater::TakeSnapshotOfRemotePartyInfosL()

    {

    CCallRemotePartyInfos* infos = CCallRemotePartyInfos::NewLC();

    for ( TInt callId = 0; callId < KPEMaximumNumberOfCalls; callId++ )

        {

        const TInt callIndex = iDataStore.CallIndex( callId );

        if ( callIndex != KPEInvalidCallIndex )

            {

            CCallRemotePartyInfo* info = CCallRemotePartyInfo::NewLC();

            info->SetCallIndex( callIndex );

            if ( iDataStore.RemoteColpNumber( callId ).Length() )

                {

                info->SetAddressL( iDataStore.RemoteColpNumber( callId ) );

                }

            else

                {

                info->SetAddressL( iDataStore.RemotePhoneNumber( callId ) );    

                }            

            info->SetMatchedNameL( iDataStore.RemoteName( callId ) );

            info->SetCompanyNameL( iDataStore.RemoteCompanyName( callId ) );

            info->SetNameFromNetworkL( iDataStore.RemotePartyName( callId ) );

            if ( iDataStore.CallOrigin( callId ) == EPECallOriginSAT )

                {

                info->SetSATCall( ETrue );

                }  

            info->SetRemoteIdentity( ResolveRemoteIdentity( callId ) );

            infos->AddL( info );

            CleanupStack::Pop( info );

            }

        }

    HBufC8* data = infos->ExternalizeL();

    CleanupStack::PopAndDestroy( infos );

    return data;

    }

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

// Sets remote party identity.

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

//

MCallRemotePartyInfo::TRemoteIdentityStatus

    TPERemotePartyInfoMediatorUpdater::ResolveRemoteIdentity( const TInt aCallId )

    {    

    MCallRemotePartyInfo::TRemoteIdentityStatus remoteIdentity;

    if ( iDataStore.CallDirection( aCallId ) == RMobileCall::EMobileOriginated  )

        {

        // In MO case Remote party address is always available 

        remoteIdentity = MCallRemotePartyInfo::ERemoteIdentityAvailable;

        }

    else

        {

        remoteIdentity = ConvertRemoteIdentity( aCallId );    

        }                 

    return remoteIdentity;

    }

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

// Converts remote party identity.

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

//

MCallRemotePartyInfo::TRemoteIdentityStatus 

    TPERemotePartyInfoMediatorUpdater::ConvertRemoteIdentity( const TInt aCallId )

    {    

    RMobileCall::TMobileCallRemoteIdentityStatus etelRemoteIdentity = iDataStore.RemoteIdentity( aCallId );    

    MCallRemotePartyInfo::TRemoteIdentityStatus remoteIdentity;

    switch ( etelRemoteIdentity )

            {

            case RMobileCall::ERemoteIdentityUnknown:

            case RMobileCall::ERemoteIdentityAvailableNoCliUnavailable:

                {

                remoteIdentity = MCallRemotePartyInfo::ERemoteIdentityUnknown;

                }

                break;

            case RMobileCall::ERemoteIdentityAvailable:

                {

                remoteIdentity = MCallRemotePartyInfo::ERemoteIdentityAvailable;

                }

                break;

            case RMobileCall::ERemoteIdentitySuppressed:

            case RMobileCall::ERemoteIdentityAvailableNoCliRejectedByUser:

                {

                remoteIdentity = MCallRemotePartyInfo::ERemoteIdentityRejectedByUser;

                }

                break;

            case RMobileCall::ERemoteIdentityAvailableNoCliInteractionWithOtherService:

            case RMobileCall::ERemoteIdentityUnavailableNoCliInteractionWithOtherService:

                {

                remoteIdentity = MCallRemotePartyInfo::ERemoteIdentityNoCliInteractionWithOtherService;

                }

                break;

            case RMobileCall::ERemoteIdentityAvailableNoCliCoinOrPayphone:

            case RMobileCall::ERemoteIdentityUnavailableNoCliCoinOrPayphone:

                {

                remoteIdentity = MCallRemotePartyInfo::ERemoteIdentityNoCliCoinOrPayphone;

                }

                break;

            default:

                {

                TEFLOGSTRING( KTAERROR, "TPERemotePartyInfoMediatorUpdater::ConvertRemoteIdentity, UNKNOWN REMOTE IDENTITY!" );

                remoteIdentity = MCallRemotePartyInfo::ERemoteIdentityUnknown;                

                break;

                }

            }    

    return remoteIdentity;

    }