/*
* 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 assign service.
*
*/


#include "CPbk2AssignService.h"

// Phonebook 2
#include "CPbk2SingleContactDataAssigner.h"
#include "CPbk2MultiContactDataAssigner.h"
#include "CPbk2ContactAttributeAssigner.h"
#include "TPbk2ServerMessageDataRetriever.h"
#include "CPbk2ServerAppAppUi.h"
#include <MPbk2ApplicationServices.h>

// Virtual Phonebook
#include <MVPbkContactLinkArray.h>

// System includes
#include <AiwContactAssignDataTypes.h>

using namespace AiwContactAssign;


/// Unnamed namespace for local definitions
namespace {

_LIT(KPanicText, "CPbk2AssignService");

enum TPanicCode
    {
    EInvalidRequest,
    EInvalidAssignType
    };

// RMessage IPC-argument slot order
const TInt KResponseSlot = 0;
const TInt KPackedResultsSlot = 0;
const TInt KExtraResultsSlot = 1;
const TInt KResultSizeSlot = 0;
const TInt KAssignInstructionsSlot = 2;

const TInt KExitAcceptedSlot = 0;           // ok to exit protocol
const TInt KExitCommandIdSlot = 1;          // ok to exit protocol
const TInt KCompleteExitCommandIdSlot = 0;  // ok to exit protocol


// Assign types
enum TAssignType
    {
    EInvalidType,
    ESingleContactDataAssign,
    EMultipleContactDataAssign,
    EContactAttributeAssign,
    };

/**
 * Retrieves assign type from given message.
 *
 * @param aMessage  Message.
 * @return  Assign type.
 */
TAssignType AssignTypeL( const RMessage2& aMessage )
    {
    TAssignType result = EInvalidType;

    TAiwContactAssignDataBasePckg dataPckg;
    aMessage.ReadL( KAssignInstructionsSlot, dataPckg );

    switch ( TAiwContactAssignDataBase::AssignDataTypeFromBuffer
            ( dataPckg ) )
        {
        case EAiwSingleContactAssignV1:
            {
            result = ESingleContactDataAssign;

            // Perform additional check for multiple preselected contacts
            TPbk2ServerMessageDataRetriever dataRetriever;
            CPbk2ServerAppAppUi& appUi = static_cast<CPbk2ServerAppAppUi&>
                ( *CEikonEnv::Static()->EikAppUi() );
            MVPbkContactLinkArray* preselectedContacts =
                dataRetriever.GetPreselectedContactLinksL
                    ( aMessage,
                      appUi.ApplicationServices().ContactManager() );
            if ( preselectedContacts && preselectedContacts->Count() > 1 )
                {
                // Multiple preselected contacts found, switch to
                // multi assign mode
                result = EMultipleContactDataAssign;
                }
            delete preselectedContacts;
            break;
            }
        case EAiwMultipleContactAssignV1:
            {
            result = EMultipleContactDataAssign;
            break;
            }
        case EAiwContactAttributeAssignV1:
            {
            result = EContactAttributeAssign;
            break;
            }
        default:
            {
            aMessage.Panic( KPanicText, EInvalidAssignType );
            break;
            }
        }
    return result;
    }

} /// namespace


// --------------------------------------------------------------------------
// CPbk2AssignService::CPbk2AssignService
// --------------------------------------------------------------------------
//
CPbk2AssignService::CPbk2AssignService( const RMessage2& aExitMsg ) :
        iExitMsg( aExitMsg )
    {
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::~CPbk2AssignService
// --------------------------------------------------------------------------
//
CPbk2AssignService::~CPbk2AssignService()
    {
    if ( !iAssignCompleteMsg.IsNull() )
        {
        iAssignCompleteMsg.Complete( KErrServerTerminated );
        }

    delete iUiService;
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::NewL
// --------------------------------------------------------------------------
//
CPbk2AssignService* CPbk2AssignService::NewL( const RMessage2& aExitMsg )
    {
    CPbk2AssignService* self =
        new ( ELeave ) CPbk2AssignService( aExitMsg );
    return self;
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::LaunchServiceL
// --------------------------------------------------------------------------
//
void CPbk2AssignService::LaunchServiceL( const RMessage2& aMessage )
    {
    if ( ( iAssignCompleteMsg.Handle() != KNullHandle ) &&
         ( iExitMsg.Handle() == KNullHandle ) )
        {
        aMessage.Panic( KPanicText, EInvalidRequest );
        }

    delete iUiService;
    iUiService = NULL;

    switch ( AssignTypeL( aMessage ) )
        {
        case ESingleContactDataAssign:
            {
            iUiService = CPbk2SingleContactDataAssigner::NewL
                ( aMessage, *this );
            break;
            }
        case EMultipleContactDataAssign:
            {
            iUiService = CPbk2MultiContactDataAssigner::NewL
                ( aMessage, *this );
            break;
            }
        case EContactAttributeAssign:
            {
            iUiService = CPbk2ContactAttributeAssigner::NewL
                ( aMessage, *this );
            break;
            }
        default:
            {
            aMessage.Panic( KPanicText, EInvalidRequest );
            break;
            }
        }

    iAssignCompleteMsg = aMessage;
    iUiService->LaunchServiceL();
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::CancelService
// --------------------------------------------------------------------------
//
void CPbk2AssignService::CancelService( const RMessage2& aMessage )
    {
    // If iAssignCompleteMsg is already completed do nothing
    if ( !iAssignCompleteMsg.IsNull() )
        {
        iUiService->CancelService();
        }

    aMessage.Complete( KErrNone );
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::GetResultsL
// --------------------------------------------------------------------------
//
void CPbk2AssignService::GetResultsL( const RMessage2& aMessage )
    {
    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
            }
        }
    aMessage.Complete( KErrNone );
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::GetResultSizeL
// --------------------------------------------------------------------------
//
void CPbk2AssignService::GetResultSizeL( const RMessage2& aMessage )
    {
    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(
                KResultSizeSlot, buffer ) );
            CleanupStack::PopAndDestroy(); // packedResults
            }
        }
    aMessage.Complete( KErrNone );
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::TryExitServiceL
// --------------------------------------------------------------------------
//
void CPbk2AssignService::TryExitServiceL( const RMessage2& aMessage )
    {
    TBool accepted = EFalse;
    TPckg<TBool> acceptedPkg( accepted );
    aMessage.ReadL( KExitAcceptedSlot, acceptedPkg );

    if ( iUiService && accepted )
        {
        TInt exitId = KErrNotFound;
        TPckg<TInt> exitPkg( exitId );
        aMessage.ReadL( KExitCommandIdSlot, exitPkg );

        iUiService->ExitServiceL( exitId );
        }

    aMessage.Complete( KErrNone );
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::TryAcceptServiceL
// --------------------------------------------------------------------------
//
void CPbk2AssignService::TryAcceptServiceL( const RMessage2& aMessage )
    {
    // Accept protocol not supported in assign
    aMessage.Complete( KErrNotSupported );
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::ServiceComplete
// --------------------------------------------------------------------------
//
void CPbk2AssignService::ServiceComplete()
    {
    if ( !iAssignCompleteMsg.IsNull() )
        {
        TPckg<TBool> complete( EFalse );
        TRAP_IGNORE( iAssignCompleteMsg.WriteL( KResponseSlot, complete ) );
        iAssignCompleteMsg.Complete( KErrNone );
        }
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::ServiceCanceled
// --------------------------------------------------------------------------
//
void CPbk2AssignService::ServiceCanceled()
    {
    if ( !iAssignCompleteMsg.IsNull() )
        {
        TPckg<TBool> cancel( ETrue );
        TRAP_IGNORE( iAssignCompleteMsg.WriteL( KResponseSlot, cancel ) );
        iAssignCompleteMsg.Complete( KErrCancel );
        }
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::ServiceAborted
// --------------------------------------------------------------------------
//
void CPbk2AssignService::ServiceAborted()
    {
    if ( !iAssignCompleteMsg.IsNull() )
        {
        iAssignCompleteMsg.Complete( KErrAbort );

        // There is nothing to do if ProcessCommandL leaves.
        // Of course it shouldn't leave in practice because it's
        // exit command.
        TRAP_IGNORE( ExitApplicationL() );
        }
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::ServiceError
// --------------------------------------------------------------------------
//
void CPbk2AssignService::ServiceError( TInt aErrorCode )
    {
    if ( !iAssignCompleteMsg.IsNull() )
        {
        TPckg<TInt> error( aErrorCode );
        TRAP_IGNORE( iAssignCompleteMsg.WriteL( KResponseSlot, error ) );
        iAssignCompleteMsg.Complete( aErrorCode );
        }
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::CompleteExitMessage
// --------------------------------------------------------------------------
//
void CPbk2AssignService::CompleteExitMessage( TInt aExitCommandId )
    {
    TPckg<TInt> exitCommandId( aExitCommandId );
    if ( iUiService && iExitMsg.Handle() != KNullHandle )
        {
        TRAP_IGNORE( iExitMsg.WriteL(
            KCompleteExitCommandIdSlot, exitCommandId ) );
        iExitMsg.Complete( KErrNone );
        }
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::CompleteAcceptMsg
// --------------------------------------------------------------------------
//
void CPbk2AssignService::CompleteAcceptMsg
        ( const TDesC8& /*aMarkedEntries*/, const TDesC8& /*aLinkData*/ )
    {
    // Not supported in assign
    }

// --------------------------------------------------------------------------
// CPbk2AssignService::ExitApplicationL
// --------------------------------------------------------------------------
//
void CPbk2AssignService::ExitApplicationL()
    {
    // Exit application
    CEikonEnv* eikonEnv = CEikonEnv::Static();
    if ( eikonEnv )
        {
        CEikAppUi* appUi = eikonEnv->EikAppUi();
        MEikCommandObserver* cmdObs =
            static_cast<MEikCommandObserver*>( appUi );

        cmdObs->ProcessCommandL( EAknCmdExit );
        }
    }

// End of File