/*

* Copyright (c) 2005-2007 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:  Phonebook 2 application server fetch service.

*

*/

#include "CPbk2FetchService.h"

// Phonebook 2

#include "CPbk2EntryFetcher.h"

#include "CPbk2ItemFetcher.h"

// Virtual Phonebook

#include <MVPbkContactLinkArray.h>

// System includes

#include <AiwContactSelectionDataTypes.h>

#include <eikappui.h>

#include <eikenv.h>

#include <avkon.hrh>

// Debug

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

_LIT(KPanicText, "CPbk2FetchService");

enum TPanicCode

    {

    EInvalidRequest,

    EInvalidSelectionType

    };

// RMessage IPC-argument slot order

const TInt KResponseSlot = 0;

const TInt KPackedResultsSlot = 0;

const TInt KExtraResultsSlot = 1;

const TInt KFieldContentSlot = 2;

const TInt KResultArraySizeSlot = 0;

const TInt KResultFieldSizeSlot = 1;

const TInt KFetchInstructionsSlot = 1;

const TInt KAcceptServiceSlot = 0;          // acception protocol

const TInt KMarkedEntriesCountSlot = 0;     // acception protocol

const TInt KSelectedLinksSlot = 1;          // acception protocol

const TInt KSelectedContactSlot = 1;        // acception protocol

const TInt KExitAcceptedSlot = 0;           // ok to exit protocol

const TInt KExitCommandIdSlot = 1;          // ok to exit protocol

const TInt KCompleteExitCommandIdSlot = 0;  // ok to exit protocol

} /// namespace

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

// CPbk2FetchService::CPbk2FetchService

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

//

CPbk2FetchService::CPbk2FetchService

        ( const RMessage2& aExitMsg, const RMessage2& aAcceptMsg ) :

            iExitMsg( aExitMsg), iAcceptMsg( aAcceptMsg )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::CPbk2FetchService()") );

    }

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

// CPbk2FetchService::~CPbk2FetchService

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

//

CPbk2FetchService::~CPbk2FetchService()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::~CPbk2FetchService()") );

    if ( !iFetchCompleteMsg.IsNull() )

        {

        iFetchCompleteMsg.Complete( KErrServerTerminated );

        }

    delete iUiService;

    }

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

// CPbk2FetchService::NewL

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

//

CPbk2FetchService* CPbk2FetchService::NewL

        ( const RMessage2& aExitMsg, const RMessage2& aAcceptMsg )

    {

    CPbk2FetchService* self =

            new ( ELeave ) CPbk2FetchService( aExitMsg, aAcceptMsg );

    return self;

    }

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

// CPbk2FetchService::LaunchServiceL

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

//

void CPbk2FetchService::LaunchServiceL( const RMessage2& aMessage )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::LaunchServiceL()") );

    if ( ( iFetchCompleteMsg.Handle() != KNullHandle ) &&

         ( iAcceptMsg.Handle() == KNullHandle ) )

        {

        aMessage.Panic( KPanicText(), EInvalidRequest );

        }

    TPbk2FetchType fetchType = FetchTypeL( aMessage );

    switch ( fetchType )

        {

        case EItemFetch:    // FALLTHROUGH

        case ECallItemFetch:

        case EMultipleItemFetch:

            {

            LaunchItemFetchL( aMessage, fetchType );

            break;

            }

        case EEntryFetch:   // FALLTHROUGH

        case EMultipleEntryFetch:

            {

            LaunchEntryFetchL( aMessage, fetchType );

            break;

            }

        default:

            {

            aMessage.Panic( KPanicText(), EInvalidRequest );

            break;

            }

        }

    }

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

// CPbk2FetchService::CancelService

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

//

void CPbk2FetchService::CancelService( const RMessage2& aMessage )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::CancelService()") );

    // If iFetchCompleteMsg is already completed do nothing.

    if ( !iFetchCompleteMsg.IsNull() )

        {

        iUiService->CancelService();

        }

    aMessage.Complete( KErrNone );

    }

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

// CPbk2FetchService::GetResultsL

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

//

void CPbk2FetchService::GetResultsL( const RMessage2& aMessage )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::GetResultsL()") );

    if ( iUiService )

        {

        MPbk2UiService::TServiceResults results;

        iUiService->ServiceResults(&results);

        if ( results.iLinkArray )

            {

            HBufC8* packedResults = results.iLinkArray->PackLC();

            TPckg<TInt> extraData(results.iExtraData);

            TRAP_IGNORE(

                aMessage.WriteL(KPackedResultsSlot, *packedResults );

                aMessage.WriteL(KExtraResultsSlot, extraData );

            );

            CleanupStack::PopAndDestroy(); // packedResults

            }

        if ( results.iFieldContent != NULL )

            {

            TRAP_IGNORE(

                aMessage.WriteL( KFieldContentSlot, *results.iFieldContent );

            );

            }

        }

    aMessage.Complete( KErrNone );

    }

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

// CPbk2FetchService::GetResultSizeL

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

//

void CPbk2FetchService::GetResultSizeL( const RMessage2& aMessage )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::GetResultSizeL()") );

    if ( iUiService )

        {

        MPbk2UiService::TServiceResults results;

        iUiService->ServiceResults(&results);

        if ( results.iLinkArray )

            {

            HBufC8* packedResults = results.iLinkArray->PackLC();

            TPtr8 ptr = packedResults->Des();

            TPckg<TInt> buffer( ptr.Size() );

            TRAP_IGNORE( aMessage.WriteL(

                KResultArraySizeSlot, buffer ) );

            CleanupStack::PopAndDestroy(); // packedResults

            }

        if ( results.iFieldContent != NULL )

            {

            TPckg<TInt> buffer( results.iFieldContent->Des().Length() );

            TRAP_IGNORE( aMessage.WriteL(

                KResultFieldSizeSlot, buffer ) );

            }

        else

            {

            TPckg<TInt> buffer( 0 );

            TRAP_IGNORE( aMessage.WriteL(

                KResultFieldSizeSlot, buffer ) );

            }

        }

    aMessage.Complete( KErrNone );

    }

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

// CPbk2FetchService::TryExitServiceL

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

//

void CPbk2FetchService::TryExitServiceL( const RMessage2& aMessage )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::TryExitServiceL()") );

    TBool okToExit = EFalse;

    TPckg<TBool> exitPkg( okToExit );

    aMessage.ReadL( KExitAcceptedSlot, exitPkg );

    if ( iUiService && okToExit )

        {

        TInt exitId = KErrNotFound;

        TPckg<TInt> commandIdPkg( exitId );

        aMessage.ReadL( KExitCommandIdSlot, commandIdPkg );

        iUiService->ExitServiceL( exitId );

        }

    aMessage.Complete( KErrNone );

    }

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

// CPbk2FetchService::TryAcceptServiceL

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

//

void CPbk2FetchService::TryAcceptServiceL( const RMessage2& aMessage )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::TryAcceptServiceL()") );

    TBool accepted = EFalse;

    TPckg<TBool> acceptedPkg( accepted );

    aMessage.ReadL( KAcceptServiceSlot, acceptedPkg );

    if ( iUiService )

        {

        HBufC8* buffer = HBufC8::NewLC(

            aMessage.GetDesMaxLengthL( KSelectedContactSlot ) );

        TPtr8 ptr = buffer->Des();

        aMessage.ReadL( KSelectedContactSlot, ptr );

        // If client accepts selected contact, call AcceptDelayedContacts

        // Otherwise call DenyDelayedContactsL

        if( accepted )

            {

            iUiService->AcceptDelayedContactsL( *buffer );

            }

        else

            {

            iUiService->DenyDelayedContactsL( *buffer );

            }

        CleanupStack::PopAndDestroy(); // buffer

        }

    aMessage.Complete( KErrNone );

    }

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

// CPbk2FetchService::ServiceComplete

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

//

void CPbk2FetchService::ServiceComplete()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::ServiceComplete()") );

    if ( !iFetchCompleteMsg.IsNull() )

        {

        TPckg<TBool> complete( EFalse );

        TRAP_IGNORE( iFetchCompleteMsg.WriteL( KResponseSlot, complete ) );

        iFetchCompleteMsg.Complete( KErrNone );

        }

    }

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

// CPbk2FetchService::ServiceCanceled

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

//

void CPbk2FetchService::ServiceCanceled()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::ServiceCanceled()") );

    if ( !iFetchCompleteMsg.IsNull() )

        {

        TPckg<TBool> cancel( ETrue );

        TRAP_IGNORE( iFetchCompleteMsg.WriteL( KResponseSlot, cancel ) );

        iFetchCompleteMsg.Complete( KErrCancel );

        }

    }

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

// CPbk2FetchService::ServiceAborted

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

//

void CPbk2FetchService::ServiceAborted()

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::ServiceAborted()") );

    if ( !iFetchCompleteMsg.IsNull() )

        {

        iFetchCompleteMsg.Complete( KErrAbort );

        // Exit application

        CEikonEnv* eikonEnv = CEikonEnv::Static();

        if ( eikonEnv )

            {

            CEikAppUi* appUi = eikonEnv->EikAppUi();

            MEikCommandObserver* cmdObs =

                static_cast<MEikCommandObserver*>( appUi );

            // Dialog is closed so there is nothing to do if

            // ProcessCommandL leaves. Of course it shouldn't leave in

            // practice because it's exit command.

            TRAP_IGNORE( cmdObs->ProcessCommandL( EAknCmdExit ) );

            }

        }

    }

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

// CPbk2FetchService::ServiceError

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

//

void CPbk2FetchService::ServiceError( TInt aErrorCode )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::ServiceError(%d)"), aErrorCode );

    TPckg<TInt> error( aErrorCode );

    TRAP_IGNORE( iFetchCompleteMsg.WriteL( KResponseSlot, error ) );

    iFetchCompleteMsg.Complete( aErrorCode );

    }

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

// CPbk2FetchService::CompleteExitMessage

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

//

void CPbk2FetchService::CompleteExitMessage( TInt aExitCommandId )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::CompleteExitMessage()") );

    TPckg<TInt> exitCommandId( aExitCommandId );

    if ( iUiService && iExitMsg.Handle() != KNullHandle )

        {

        TRAP_IGNORE( iExitMsg.WriteL(

            KCompleteExitCommandIdSlot, exitCommandId ) );

        iExitMsg.Complete( KErrNone );

        }

    }

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

// CPbk2FetchService::CompleteAcceptMsg

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

//

void CPbk2FetchService::CompleteAcceptMsg

        ( const TDesC8& aMarkedEntries, const TDesC8& aLinkData )

    {

    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING

        ("CPbk2FetchService::CompleteAcceptMsg()") );

    if ( iUiService && iAcceptMsg.Handle() != KNullHandle )

        {

        // Verify that we have enough room in the buffer

        TInt maxSize = 0;

        TRAP_IGNORE( 

            maxSize = iAcceptMsg.GetDesMaxLengthL( KSelectedLinksSlot ) );

        TInt bufferSize = aLinkData.Size();

        if ( bufferSize > maxSize )

            {

            iAcceptMsg.Complete( KErrOverflow );

            }

        else

            {

            TRAP_IGNORE(

                {

                iAcceptMsg.WriteL( KMarkedEntriesCountSlot, aMarkedEntries );

                iAcceptMsg.WriteL( KSelectedLinksSlot, aLinkData );                

                });

            iAcceptMsg.Complete( KErrNone );

            }

        }

    }

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

// CPbk2FetchService::LaunchEntryFetchL

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

//

void CPbk2FetchService::LaunchEntryFetchL

        ( const RMessage2& aMessage, TPbk2FetchType aFetchType )

    {

    delete iUiService;

    iUiService = NULL;

    iUiService = CPbk2EntryFetcher::NewL( aMessage, *this, aFetchType );

    iUiService->LaunchServiceL();

    iFetchCompleteMsg = aMessage;

    }

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

// CPbk2FetchService::LaunchItemFetchL

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

//

void CPbk2FetchService::LaunchItemFetchL

        ( const RMessage2& aMessage, TPbk2FetchType aFetchType )

    {

    delete iUiService;

    iUiService = NULL;

    iUiService = CPbk2ItemFetcher::NewL( aMessage, *this, aFetchType );

    iUiService->LaunchServiceL();

    iFetchCompleteMsg = aMessage;

    }

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

// CPbk2FetchService::FetchTypeL

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

//

TPbk2FetchType CPbk2FetchService::FetchTypeL( const RMessage2& aMessage )

    {

    TPbk2FetchType result = EInvalidType;

    TInt length = aMessage.GetDesLengthL( KFetchInstructionsSlot );

    if ( length > 0 )

        {

        HBufC8* dataBuf = HBufC8::NewLC( length );

        TPtr8 ptr = dataBuf->Des();

        aMessage.ReadL( KFetchInstructionsSlot, ptr );

        TAiwContactSelectionDataType dataType =

            TAiwContactSelectionDataBase::SelectionDataTypeFromBuffer( ptr );

        switch ( dataType )

            {

            case EAiwSingleEntrySelectionV1:        // FALLTHROUGH

            case EAiwSingleEntrySelectionV2:

                {

                result = EEntryFetch;

                break;

                }

            case EAiwMultipleEntrySelectionV1:      // FALLTHROUGH

            case EAiwMultipleEntrySelectionV2:

                {

                result = EMultipleEntryFetch;

                break;

                }

            case EAiwSingleItemSelectionV1:

                {

                TAiwSingleItemSelectionDataV1Pckg data;

                data.Copy( ptr );

                result = EItemFetch;

                TAiwAddressSelectType addressSelectType =

                    data().AddressSelectType();

                if ( addressSelectType == EAiwCallItemSelect

                     || addressSelectType == EAiwVoIPItemSelect )

                    {

                    result = ECallItemFetch;

                    }

                break;

                }

            case EAiwSingleItemSelectionV2:

                {

                result = EItemFetch;

                break;

                }

            case EAiwSingleItemSelectionV3:

                {

                TAiwSingleItemSelectionDataV3Pckg data;

                data.Copy( ptr );

                result = EItemFetch;

                TAiwAddressSelectType addressSelectType =

                    data().AddressSelectType();

                if ( addressSelectType == EAiwCallItemSelect

                     || addressSelectType == EAiwVoIPItemSelect )

                    {

                    result = ECallItemFetch;

                    }

                break;

                }

            case EAiwMultipleItemSelectionV1: