/*

* 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 Assign UI service AIW provider.

*

*/

#include "CPbk2AiwAssignProvider.h"

// Phonebook 2

#include "CPbk2ServerAppConnection.h"

#include "Pbk2UIServices.hrh"

#include <Pbk2IPCPackage.h>

#include <Pbk2DataCaging.hrh>

#include <Pbk2MimeTypeHandler.h>

#include <Pbk2InternalUID.h>

// Virtual Phonebook

#include <VPbkPublicUid.h>

// System includes

#include <AiwMenu.h>

#include <AiwContactAssignDataTypes.h>

#include <s32mem.h>

#include <eikspane.h>

#include <akntitle.h>

#include <avkon.hrh>

#include <featmgr.h>

#include <aknViewAppUi.h>

using namespace AiwContactAssign;

/// Unnamed namespace for local definitions

namespace {

_LIT(KPbk2UiServicesDllResFileName, "Pbk2UiServicesRes.rsc");

_LIT(KPbk2UiControlsDllResFileName, "Pbk2UiControls.rsc");

#ifdef _DEBUG

enum TPanicCode

    {

    ENullPointer,

    EInvalidArgument,

    EDataTypeNotSupported

    };

void Panic(TPanicCode aReason)

    {

    _LIT( KPanicText, "CPbk2AiwAssignProvider" );

    User::Panic( KPanicText, aReason );

    }

#endif // _DEBUG

/**

 * Verifies whether the given command id is handled here.

 * This should be done by AIW.

 *

 * @param aCmdId    The command id to check.

 * @return  ETrue if command is handled by this provider

 */

inline TBool IsCorrectAiwCmd( const TInt aCmdId )

    {

    TBool ret = EFalse;

    switch ( aCmdId )

        {

        case KAiwCmdAssign:                     // FALLTHROUGH

        case EPbk2AiwCmdAssign:                 // FALLTHROUGH

        case EPbk2AiwCmdDataSaveCreateNew:      // FALLTHROUGH

        case EPbk2AiwCmdDataSaveAddToExisting:

            {

            ret = ETrue;

            break;

            }

        default:        

            {

            // Do nothing

            break;

            }

        }

    return ret;

    }

/**

 * Finds a AIW semantic id from the AIW in param list.

 *

 * @param aInParamList    AIW in param list.

 * @param aSemanticId     The semantic id to look for.

 * @return  ETrue if found, EFalse otherwise.

 */

inline TBool FindSemanticId

        ( const CAiwGenericParamList& aInParamList,

          const TGenericParamId aSemanticId )

    {

    TBool ret = EFalse;

    TInt index = 0;

    if ( aInParamList.FindFirst( index, aSemanticId ) )

        {

        ret = ETrue;

        }

    return ret;

    }

/**

 * Validates that param's data is valid

 *

 * @param aInParamList  The data passed by the consumer.

 * @param aSemanticId   The param which data to be validate.

 * @return ETrue if data is valid, EFalse otherwise

 */

inline TBool ValidateData

        ( const CAiwGenericParamList& aInParamList, 

          TGenericParamId aSemanticId )

    {

    TBool result = ETrue;

    // EGenericParamMIMEType param data validation

    if ( EGenericParamMIMEType == aSemanticId )

        {

        TInt index = 0;

        const TAiwGenericParam* mimeTypeParam =

            aInParamList.FindFirst( index, EGenericParamMIMEType,

                EVariantTypeDesC );

        TInt error = KErrNone;

        TInt mimeType = Pbk2MimeTypeHandler::EMimeTypeNotSupported;

        if ( mimeTypeParam )

            {            

            TRAP( error,

                {                

                if ( mimeTypeParam->Value().AsData().Ptr() )

                    {

                    // 8-bit

                    mimeType = Pbk2MimeTypeHandler::MapMimeTypeL

                        ( mimeTypeParam->Value().AsData() );

                    }

                else if ( mimeTypeParam->Value().AsDes().Ptr() )

                    {

                    // 16-bit

                    mimeType = Pbk2MimeTypeHandler::MapMimeTypeL

                        ( mimeTypeParam->Value().AsDes() );

                    }

                } ); // TRAP

            }

        // No MIME type found if leaves with KErrNotFound.

        // Not supported type if mimeType is not found.

        if ( error == KErrNotFound  || 

             Pbk2MimeTypeHandler::EMimeTypeNotSupported == mimeType )

            {

            result = EFalse;

            }            

        }

    return result;

    }

/**

 * Validates that consumer passed all required data.

 * Checks also if required param EGenericParamMIMEType data is valid.

 * If invalid data is given leave KErrArgument will occur.

 *

 * @param aInParamList  The data passed by the consumer.

 * @return  EGenericParamUnspecified if no valid data is found,

 *          AIW semantic id of found data otherwise.

 */

inline TGenericParamId ValidateParams

        ( const CAiwGenericParamList& aInParamList )

    {

    TGenericParamId ret = EGenericParamUnspecified;

    if ( FindSemanticId( aInParamList, EGenericParamPhoneNumber ) )

        {

        ret = EGenericParamPhoneNumber;

        }

    else if ( FindSemanticId( aInParamList, EGenericParamEmailAddress ) )

        {

        ret = EGenericParamEmailAddress;

        }

    else if ( FindSemanticId( aInParamList, EGenericParamSIPAddress ) )

        {

        ret = EGenericParamSIPAddress;

        }

    else if ( FindSemanticId( aInParamList, EGenericParamURL ) )

        {

        ret = EGenericParamURL;

        }

    else if ( FindSemanticId( aInParamList, EGenericParamWVID ) )

        {

        ret = EGenericParamWVID;

        }

    else if ( FindSemanticId( aInParamList, EGenericParamSpeedDialIndex ) )

        {

        ret = EGenericParamSpeedDialIndex;

        }

    else if ( FindSemanticId( aInParamList, EGenericParamXSpId ) )

        {

        ret = EGenericParamXSpId;

        }

    else if ( FindSemanticId( aInParamList, EGenericParamContactItem ) )

        {

        ret = EGenericParamContactItem;

        }

    if ( ret == EGenericParamUnspecified )

        {

        // The in param list must have a MIME type with the data and file name

        if ( FindSemanticId( aInParamList, EGenericParamMIMEType ) && 

             ValidateData( aInParamList, EGenericParamMIMEType ) )

            {            

            if ( FindSemanticId( aInParamList, EGenericParamFile ) )

                {

                // In this case, return EGenericParamFile

                ret = EGenericParamFile;

                }

            }

        }

    return ret;

    }

/**

 * Selects correct address select selector matching the passed parameters.

 *

 * @param aInParamList  Parameter list.

 * @return  Selector resource id.

 */

TInt SelectSelectorResourceIdFromParams

        ( const CAiwGenericParamList& aInParamList )

    {

    TInt resourceId = KErrNotFound;

    if ( FindSemanticId( aInParamList, EGenericParamPhoneNumber ) )

        {

        if( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

            {

            resourceId = R_PBK2_AIW_PHONENUMBER_SELECTOR_VOIP;

            }

        else

            {

            resourceId = R_PBK2_AIW_PHONENUMBER_SELECTOR;

            }

        }

    else if ( FindSemanticId( aInParamList, EGenericParamEmailAddress ) )

        {

        if( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

            {

            resourceId = R_PBK2_AIW_EMAIL_SELECTOR_VOIP;

            }

        else

            {

            resourceId = R_PBK2_AIW_EMAIL_SELECTOR;

            }

        }

    else if ( FindSemanticId( aInParamList, EGenericParamSIPAddress ) )

        {

        if( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

            {

            resourceId = R_PBK2_AIW_SIP_SELECTOR_VOIP;

            }

        else

            {

            resourceId = R_PBK2_AIW_SIP_SELECTOR;

            }

        }

    else if ( FindSemanticId( aInParamList, EGenericParamURL ) )

        {

        resourceId = R_PBK2_AIW_URL_SELECTOR;

        }

    else if ( FindSemanticId( aInParamList, EGenericParamWVID ) )

        {

        // Not supported yet

        }

    else if ( FindSemanticId( aInParamList, EGenericParamDateTime ) )

        {

        // Not supported yet

        }

    else if ( FindSemanticId( aInParamList, EGenericParamXSpId ) )

        {

        resourceId = R_PBK2_AIW_IMPP_SELECTOR;

        }

    else

        {

        TInt index = 0;

        // Lets then try MIME type param

        const TAiwGenericParam* mimeTypeParam =

            aInParamList.FindFirst( index, EGenericParamMIMEType,

                EVariantTypeDesC );

        if ( mimeTypeParam )

            {

            // If MIME type is specified, then the selector resource

            // depends on the type of MIME

            TInt mimeType( 0 );

            if ( mimeTypeParam->Value().AsData().Ptr() )

                {

                // 8-bit

                mimeType = Pbk2MimeTypeHandler::MapMimeTypeL

                    ( mimeTypeParam->Value().AsData() );

                }

            else if ( mimeTypeParam->Value().AsDes().Ptr() )

                {

                // 16-bit

                mimeType = Pbk2MimeTypeHandler::MapMimeTypeL

                    ( mimeTypeParam->Value().AsDes() );

                }

            switch ( mimeType )

                {

                case Pbk2MimeTypeHandler::EMimeTypeImage:

                    {

                    resourceId = R_PBK2_AIW_THUMBNAIL_SELECTOR;

                    break;

                    }

                case Pbk2MimeTypeHandler::EMimeTypeAudio:   // FALLTHROUGH

                case Pbk2MimeTypeHandler::EMimeTypeVideo:

                    {

                    resourceId = R_PBK2_AIW_RINGTONE_SELECTOR;

                    break;

                    }

                default:

                    {

                    // Do nothing

                    break;

                    }

                }

            }

        }

    return resourceId;

    }

/**

 * Selects correct contact view filter selector matching

 * the passed parameters.

 *

 * @param aInParamList  Parameter list.

 * @return  Selector resource id.

 */

TInt SelectFilterResourceIdFromParams

        ( const CAiwGenericParamList& aInParamList )

    {

    TInt resourceId = KErrNotFound;

    if ( FindSemanticId( aInParamList, EGenericParamSpeedDialIndex ) )

        {

        resourceId = R_PHONEBOOK2_PHONENUMBER_SELECTOR;

        }

    return resourceId;

    }

} /// namespace

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

// CPbk2AiwAssignProvider::CPbk2AiwAssignProvider

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

//

CPbk2AiwAssignProvider::CPbk2AiwAssignProvider()

        : iUiServicesResourceFile( *CCoeEnv::Static() )

    {

    }

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

// CPbk2AiwAssignProvider::~CPbk2AiwAssignProvider

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

//

CPbk2AiwAssignProvider::~CPbk2AiwAssignProvider()

    {

    delete iConnection;

    delete iEventParamList;

    delete iDataPackage;

    delete iConfigurationPackage;

    delete iInstructionsPackage;

    iUiServicesResourceFile.Close();

    FeatureManager::UnInitializeLib();

    }

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

// CPbk2AiwAssignProvider::NewL

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

//

CPbk2AiwAssignProvider* CPbk2AiwAssignProvider::NewL()

    {

    CPbk2AiwAssignProvider* self = new ( ELeave)  CPbk2AiwAssignProvider;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2AiwAssignProvider::ConstructL

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

//

void CPbk2AiwAssignProvider::ConstructL()

    {

    iUiServicesResourceFile.OpenL(KPbk2RomFileDrive,

        KDC_RESOURCE_FILES_DIR, KPbk2UiServicesDllResFileName);

    FeatureManager::InitializeLibL();

    }

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

// CPbk2AiwAssignProvider::InitializeMenuPaneL

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

//

void CPbk2AiwAssignProvider::InitializeMenuPaneL

        ( CAiwMenuPane& aMenuPane, TInt aIndex,

          TInt /*aCascadeId*/, const CAiwGenericParamList& aInParamList)

    {

    TAiwGenericParam param = ValidateParams(aInParamList);

    if (param != EGenericParamUnspecified)

        {

        // Initialize with the default menu

        TInt menuResourceId = R_PBK2_AIW_ASSIGN;

        CreateInstructionPackageL( aInParamList );

        if (iInstructionsPackage)

            {

            TInt version = TAiwContactAssignDataBase::

                AssignDataTypeFromBuffer( *iInstructionsPackage );

            if (version == EAiwMultipleContactAssignV1)

                {

                // Multi assign has always just one menu option,

                // and it has already been set

                }

            else if (version == EAiwSingleContactAssignV1)

                {

                // Single assign defaults to R_PBK2_AIW_ADD_TO_CONTACTS,

                // but if there is a raised EUseSimpleMenu flag

                // then we show the R_PBK2_AIW_ASSIGN menu

                TAiwSingleContactAssignDataV1Pckg data;

                data.Copy( *iInstructionsPackage );

                TUint assignFlags = data().Flags();

                if ( !( assignFlags & EUseSimpleMenu ) )

                    {

                    if (param == EGenericParamXSpId)

                        {

                        menuResourceId = R_PBK2_AIW_ADD_TO_CONTACTS_XSP;

                        }

                    else

                        {

                        menuResourceId = R_PBK2_AIW_ADD_TO_CONTACTS;

                        }

                    }

                }

            else

                {

                User::Leave( KErrArgument );

                }

            }

        // Show the menu

        TResourceReader reader;

        CCoeEnv::Static()->CreateResourceReaderLC

            (reader, menuResourceId);

        aMenuPane.AddMenuItemsL(reader, KAiwCmdAssign, aIndex);

        CleanupStack::PopAndDestroy(); // reader

        }

    }

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

// CPbk2AiwAssignProvider::HandleMenuCmdL

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

//

void CPbk2AiwAssignProvider::HandleMenuCmdL

        ( TInt aMenuCmdId, const CAiwGenericParamList& aInParamList,

          CAiwGenericParamList& aOutParamList,

          TUint aCmdOptions, const MAiwNotifyCallback* aCallback )

    {

    // Route to HandleServiceCmdL

    HandleServiceCmdL( aMenuCmdId, aInParamList,

        aOutParamList, aCmdOptions, aCallback );

    }

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

// CPbk2AiwAssignProvider::InitialiseL

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

//

void CPbk2AiwAssignProvider::InitialiseL

        ( MAiwNotifyCallback& /*aFrameworkCallback*/,

          const RCriteriaArray& /*aInterest*/ )

    {

    // Nothing needs to be done

    }

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

// CPbk2AiwAssignProvider::HandleServiceCmdL

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

//

void CPbk2AiwAssignProvider::HandleServiceCmdL

        ( const TInt& aCmdId, const CAiwGenericParamList& aInParamList,

        CAiwGenericParamList& /*aOutParamList*/,

        TUint aCmdOptions, const MAiwNotifyCallback* aCallback )

    {

    if ( IsCorrectAiwCmd( aCmdId ) )

        {

        if ( !iConnection )

            {

            iConnection = CPbk2ServerAppConnection::NewL( *this );

            }

        else if( iConnection->IsActive() )

            {

	            	if ( aCmdOptions & KAiwOptCancel )

								{

								// Client wants to cancel existing service

								iConnection->CancelAssign();

								}