/*

* 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:   Calls voice call or VoIP call to either of addresses provided. 

*

*/

#include <eikenv.h>

#include <coemain.h>

#include <ItemFinder.h>

#include <msgvoipextension.h>

#include <commonphoneparser.h>      // Common phone number validity checker

#include "MuiuContactService.h"

#include "MuiuContactAddressMatcher.h"

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

// CMuiuContactService::NewL

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

EXPORT_C CMuiuContactService* CMuiuContactService::NewL( 

        CEikonEnv&          aEnv,

        CMsgVoIPExtension*  aVoipExtension ) 

    {

    CMuiuContactService* self =

        new( ELeave ) CMuiuContactService( aEnv, aVoipExtension );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMuiuContactService::CMuiuContactService

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

CMuiuContactService::CMuiuContactService(   CEikonEnv&          aEnv,

                                            CMsgVoIPExtension*  aVoipExtension ):

    iEikEnv( aEnv ),

    iVoipExtension( aVoipExtension )

    {

    }

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

// CMuiuContactService::ConstructL

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

void CMuiuContactService::ConstructL()

    {

    if ( !iVoipExtension )

        {

        iVoipExtension = CMsgVoIPExtension::NewL( );

        }

    }

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

// CMuiuContactService::~CMuiuContactService

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

EXPORT_C CMuiuContactService::~CMuiuContactService()

    {

    delete iVoipExtension;

    delete iContactAddressMatcher;

    delete iMatchAddress;

    delete iMatchName;

    }

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

// CMuiuContactService::PreferredCallTypeL

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

EXPORT_C CMuiuContactService::TMuiuPreferredCallType CMuiuContactService::PreferredCallTypeL() const

    {

    CMuiuContactService::TMuiuPreferredCallType preferredCallType( EMuiuCallTypeVoice );

    if (    iVoipExtension

        &&  iVoipExtension->IsPreferredTelephonyVoIP( )

        &&  iVoipExtension->VoIPProfilesExistL() )

        {

        preferredCallType = EMuiuCallTypeVoip;

        }

    return preferredCallType;

    }

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

// CMuiuContactService::SetAddress

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

EXPORT_C void CMuiuContactService::SetAddress( const TDesC& aAddress )

    {

    if ( iWait.IsStarted( ) )

        {

        // if searching, changes are not allowed, which may affect call handling

        // iPrimaryAddress may be used after search completes

        return;

        }

    iPrimaryAddress.Set( aAddress );

    delete iMatchAddress;

    iMatchAddress = NULL;

    delete iMatchName;

    iMatchName = NULL;

    }

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

// CMuiuContactService::SetName

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

EXPORT_C void CMuiuContactService::SetName( const TDesC& aName )

    {

    if ( iWait.IsStarted( ) )

        {

        // if searching, changes are not allowed, which may affect call handling

        // iPrimaryName may be used after search completes

        return;

        }

    iPrimaryName.Set( aName );

    delete iMatchAddress;

    iMatchAddress = NULL;

    delete iMatchName;

    iMatchName = NULL;

    }

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

// CMuiuContactService::CallL

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

EXPORT_C TBool CMuiuContactService::CallL( )

    {

    return CallL( KNullDesC );

    }

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

// CMuiuContactService::CallL

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

EXPORT_C TBool CMuiuContactService::CallL( const TDesC& aSecondaryAddress )

    {

    if ( iWait.IsStarted( ) )

        {

        // if searching, changes are not allowed, which may affect call handling

        User::Leave( KErrNotSupported );

        }

    TBool ret = EFalse;

    // Primary address data

    TPtrC primaryAddress( KNullDesC );

    TPtrC primaryName( KNullDesC );

    TMuiuAddressType primaryAddressType = MsvUiServiceUtilitiesInternal::ResolveAddressTypeL( 

              iPrimaryAddress ); 

    // resolve type of secondary (find item) address

    iSecondaryAddress.Set( aSecondaryAddress );

    TMuiuAddressType secondaryAddressType = MsvUiServiceUtilitiesInternal::ResolveAddressTypeL( 

        iSecondaryAddress ); 

    // Get preferred call type    

    CMuiuContactService::TMuiuPreferredCallType preferredCallType = PreferredCallTypeL( );

    if ( preferredCallType == EMuiuCallTypeVoice ) 

        {

        TMuiuAddressType foundAddressType = MsvUiServiceUtilitiesInternal::ResolveAddressTypeL( 

              FoundContactAddressL() ); 

        if (    primaryAddressType == EMuiuAddressTypeEmail

            &&  foundAddressType !=  EMuiuAddressTypePhoneNumber )

            {

            // Search to phonebook must be done, if sender's address is email and

            // found address is not phone number

            ret = ETrue;

            if ( !iContactAddressMatcher )

                {

                iContactAddressMatcher = CMuiuContactAddressMatcher::NewL( iEikEnv ); 

                }

            iContactAddressMatcher->FindContactL(   iPrimaryAddress,

                                                    TCallBack( MatchDone, this) );

            iWait.Start( );

            // get results

            delete iMatchAddress;

            iMatchAddress = NULL;

            delete iMatchName;

            iMatchName = NULL;

            iMatchAddress = iContactAddressMatcher->GetAddressL();    

            iMatchName = iContactAddressMatcher->GetNameL(); 

            if (    iMatchAddress

                &&  iMatchAddress->Length() )

                {

                // Use found address 

                primaryAddress.Set( FoundContactAddressL() );

                primaryAddressType = 

                    MsvUiServiceUtilitiesInternal::ResolveAddressTypeL( primaryAddress );

                // Use 'remote' alias, if it is visible on the UI

                if ( iPrimaryName.Length() == 0 )

                    {

                    primaryName.Set( FoundContactNameL() );

                    }

                }

            else 

                {

                // If found contact had not address, use primary address whatever it was. 

                // Ignore also found name

                primaryAddress.Set( iPrimaryAddress );

                primaryName.Set( iPrimaryName );

                }

            }

        else if ( foundAddressType == EMuiuAddressTypePhoneNumber )

            {                        

            // Use search results

            primaryAddress.Set( FoundContactAddressL() );

            primaryAddressType = 

                MsvUiServiceUtilitiesInternal::ResolveAddressTypeL( primaryAddress );

            // Use 'remote' alias, if it is visible on the UI

            if ( iPrimaryName.Length() == 0 )

                {

                primaryName.Set( FoundContactNameL() );

                }

            }

        else if ( primaryAddressType == EMuiuAddressTypePhoneNumber )

            {

            //  Use original address  

            primaryAddress.Set( iPrimaryAddress );

            primaryName.Set( iPrimaryName );              

            }

        else

            {

            primaryAddressType = EMuiuAddressTypeNone;

            }

        }

    else if ( preferredCallType != EMuiuCallTypeVoip )

        {

        return EFalse;

        }

    else // preferredCallType == EMuiuCallTypeVoip. Use original address information

        {

        primaryAddress.Set( iPrimaryAddress );

        primaryName.Set( iPrimaryName );

        }

    MsvUiServiceUtilitiesInternal::InternetOrVoiceCallServiceL( 

        iEikEnv,

        *iVoipExtension,

        primaryAddress,

        primaryName,

        primaryAddressType,

        iSecondaryAddress,

        secondaryAddressType,

        EFalse );

    return ret;

    }

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

// CMuiuContactService::CallL

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

EXPORT_C TBool CMuiuContactService::CallL( CItemFinder* aSecondaryItem )

    {

    TPtrC focusedAddr = KNullDesC( );

    if ( aSecondaryItem )

        {

        CItemFinder::CFindItemExt& item =

            aSecondaryItem->CurrentItemExt();

        if (    item.iItemDescriptor

            &&  (   item.iItemType == CItemFinder::EPhoneNumber

                ||  item.iItemType == CItemFinder::EEmailAddress ) )

            {

            focusedAddr.Set( *(item.iItemDescriptor) );

            }

        }

    return CallL( focusedAddr );

    }

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

// CMuiuContactService::IsContactFound

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

EXPORT_C TBool CMuiuContactService::IsContactFound() const

    {

    if ( iMatchAddress )

        {

        return iMatchAddress->Length();

        }

    return EFalse;

    }

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

// CMuiuContactService::FoundContactAddressL

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

EXPORT_C TPtrC CMuiuContactService::FoundContactAddressL() const

    {

    if ( iMatchAddress )

        {

        return *iMatchAddress;

        }

    return KNullDesC();

    }

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

// CMuiuContactService::FoundContactNameL

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

EXPORT_C TPtrC CMuiuContactService::FoundContactNameL() const

    {

    if ( iMatchName )

        {

        return *iMatchName;

        }

    return KNullDesC();

    }

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

// CMuiuContactService::IsVoipSupported

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

EXPORT_C TBool CMuiuContactService::IsVoipSupported() const

    {        

    if (    iVoipExtension

        &&  iVoipExtension->IsVoIPSupported( ) )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CMuiuContactService::MatchDone

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

TInt CMuiuContactService::MatchDone( TAny* aCallService )

    {

    CMuiuContactService* caller =

        static_cast<CMuiuContactService*>( aCallService );

    caller->iWait.AsyncStop( );

    return KErrNone;

    }

// End of File