/*

* Copyright (c) 2008 - 2010 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:  handles interface to LIW and Content Publishing Service

*

*/

#include <cmailhandlerplugin.mbg>

#include <AknUtils.h>

#include <gulicon.h>

#include <bautils.h>

#include <StringLoader.h>

#include <emailwidget.rsg>

#include "emailtrace.h"

#include "cfsmailclient.h"

#include "cmailcpsif.h"

#include "cmailcpsifconsts.h"

#include "FreestyleEmailUiConstants.h"

#include "cmailwidgetcenrepkeysinternal.h"

// ======== MEMBER FUNCTIONS ========

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

// CMailCpsIf::NewL

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

//

CMailCpsIf* CMailCpsIf::NewL( CMailCpsHandler* aMailCpsHandler )

    {

    FUNC_LOG;

    CMailCpsIf* self = new(ELeave) CMailCpsIf( aMailCpsHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMailCpsIf::CMailCpsIf

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

//

CMailCpsIf::CMailCpsIf( CMailCpsHandler* aMailCpsHandler ) :

    iMailCpsHandler( aMailCpsHandler ),

    iMsgInterface ( NULL ),

    iIgnoreHsNotifications( EFalse )

    {

    FUNC_LOG;

    }

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

// CMailCpsIf::ConstructL

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

//

void CMailCpsIf::ConstructL()

    {

    FUNC_LOG;

    for (TInt i=0; i<KMaxMailboxCount; i++)

        {

        iAllowedToPublish[i] = EFalse;

        }

    AllocateResourcesL();

    iMsgInterface = GetMessagingInterfaceL();

    RegisterForObserverL();

    PublisherRegisteryActionL();

    ResetPublishedDataL( KCPAll );

    iContentControlClient = CHsCcApiClient::NewL( this );

    }

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

// CMailCpsIf::~CMailCpsIf

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

//

CMailCpsIf::~CMailCpsIf()

    {

    FUNC_LOG;

    TRAP_IGNORE(UnRegisterForObserverL());

    if ( iMsgInterface )

        {

        iMsgInterface->Close();

        iMsgInterface = NULL;

        }

    delete iServiceHandler;

    for ( TInt i = 0; i < iInstIdList.Count(); i++ )

        {

        iInstIdList.Remove(i);

        }

    CCoeEnv::Static()->DeleteResourceFile( iResourceFileOffset );

    if ( iContentControlClient ) 

        {

        delete iContentControlClient;

        }

    }

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

// CMailCpsIf::AllocateResourcesL

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

//

void CMailCpsIf::AllocateResourcesL()

    {

    FUNC_LOG;

    // create resourcefile 

    CCoeEnv* env = CCoeEnv::Static();

    // Load resource file from the same drive where this dll is loaded from

    TFileName dllFileName;

    Dll::FileName( dllFileName );

    TParse parse;

    User::LeaveIfError( parse.Set( KResourceFile, &dllFileName, NULL ) );

    TFileName resourceFile( parse.FullName() );

    BaflUtils::NearestLanguageFile( env->FsSession(), resourceFile );

    iResourceFileOffset = env->AddResourceFileL( resourceFile );

    }

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

// CMailCpsIf::GetMessagingInterfaceL

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

//

MLiwInterface* CMailCpsIf::GetMessagingInterfaceL()

    {

    FUNC_LOG;

    if ( !iServiceHandler )

        {

        iServiceHandler = CLiwServiceHandler::NewL();

        }

    CLiwGenericParamList* inParam = CLiwGenericParamList::NewL();

    CleanupStack::PushL( inParam );

    CLiwGenericParamList* outParam = CLiwGenericParamList::NewL();

    CleanupStack::PushL( outParam );

    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL( KLiwCmdAsStr, KCPInterface,

        KCPService  );

    crit->SetServiceClass( TUid::Uid(KLiwClassBase) );

    RCriteriaArray criteriaArray;

    criteriaArray.AppendL( crit );

    iServiceHandler->AttachL( criteriaArray );

    iServiceHandler->ExecuteServiceCmdL( *crit, *inParam, *outParam );

    delete crit;

    crit = NULL;

    criteriaArray.Reset();

    // find service interface

    TInt pos = 0;

    MLiwInterface* msgInterface = NULL;

    outParam->FindFirst( pos, KCPInterface );

    if ( pos != KErrNotFound )

        {

        msgInterface = (*outParam)[pos].Value().AsInterface(); // indexing should be safe

        }

    outParam->Reset();

    inParam->Reset();

    if( !msgInterface )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( outParam );

    CleanupStack::PopAndDestroy( inParam );

    return msgInterface;

    }

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

// CMailCpsIf::PublishSetupWizardL

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

//

void CMailCpsIf::PublishSetupWizardL(TInt aInstance)

    {

    FUNC_LOG;

    if (!iInstIdList[aInstance].iWizardPublished)

        {

        TFSMailMsgId mailBoxId;

        TFSMailMsgId folderId;

       HBufC* setupEmail = StringLoader::LoadLC(R_EMAILWIDGET_TEXT_SETUP_EMAIL);

        iSetupUid = PublishDescriptorL(

            KPubId, KContTypeSetupText,

            iInstIdList[aInstance].iCid,

            *setupEmail, 

            KKeySetupText, KTriggerWizard8);

        PublishImageL(

            iInstIdList[aInstance].iCid,

            KContTypeSetupIcon,

            KKeySetupIcon,

            EMbmCmailhandlerpluginQgn_prop_cmail_new_mailbox,

            EMbmCmailhandlerpluginQgn_prop_cmail_new_mailbox_mask,

            mailBoxId,

            KNullDes);

        PublishImageL(

            iInstIdList[aInstance].iCid,

            KContTypeSetupBrandIcon1,

            KKeySetupBrandIcon1,

            EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account,

            EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account_mask,

            mailBoxId,

            KSetupBrand1);

        PublishImageL(

            iInstIdList[aInstance].iCid,

            KContTypeSetupBrandIcon2,

            KKeySetupBrandIcon2,

            EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account,

            EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account_mask,

            mailBoxId,

            KSetupBrand2);

        PublishImageL(

            iInstIdList[aInstance].iCid,

            KContTypeSetupBrandIcon3,

            KKeySetupBrandIcon3,

            EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account,

            EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account_mask,

            mailBoxId,

            KSetupBrand3);

        PublishImageL(

            iInstIdList[aInstance].iCid,

            KContTypeSetupBrandIcon4,

            KKeySetupBrandIcon4,

            EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account,

            EMbmCmailhandlerpluginQgn_indi_cmail_drop_email_account_mask,

            mailBoxId,

            KSetupBrand4);

        iInstIdList[aInstance].iWizardPublished = ETrue;

        CleanupStack::PopAndDestroy(setupEmail);

        }        

    }

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

// CMailCpsIf::PublishActiveMailboxNameL

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

//

void CMailCpsIf::PublishActiveMailboxNameL(

    const TInt aInstance,

    const TInt aRowNumber, 

    const TDesC& aMailboxName)

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> row;

    row.Num(aRowNumber);

    TBuf<KMaxDescLen> contentType;

    contentType.Copy(KContTypeBodyText);        

    contentType.Append(row);

    TBuf<KMaxDescLen> textKey;

    textKey.Copy(KKeyBodyText);

    textKey.Append(row);

    iMailboxNameUid = PublishDescriptorL(

        KPubId, contentType, 

        iInstIdList[aInstance].iCid,        

        aMailboxName,

        textKey, KTriggerEmailUi8);

    }

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

// CMailCpsIf::PublishActiveMailboxNameL

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

//

void CMailCpsIf::PublishMailboxNameL(

    const TInt aInstance, 

    const TDesC& aMailboxName,

    const TDesC8& aAction )

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> contentType;

    contentType.Copy(KContTypeBodyText);        

    contentType.Append(_L("1"));

    TBuf<KMaxDescLen> textKey;

    textKey.Copy(KKeyBodyText);

    textKey.Append(_L("1"));

    TFSMailMsgId dummy;

    PublishDescriptorL( KPubId, contentType, iInstIdList[aInstance].iCid,

        aMailboxName, textKey, aAction);        

    }

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

// CMailCpsIf::PublishIndicatorIconL

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

//

void CMailCpsIf::PublishIndicatorIconL( const TInt aInstance, 

                                        const TInt aRowNumber,

                                        const TInt aIcon )

    {

    FUNC_LOG;

    TFSMailMsgId mailBoxId;

    TBuf<KMaxDescLen> row;

    row.Num(aRowNumber);

    TBuf<KMaxDescLen> contentType;

    contentType.Copy(KContTypeIndicatorIcon);        

    contentType.Append(row);

    TBuf8<KMaxDescLen> row8;

    row8.Num(aRowNumber);

    TBuf8<KMaxDescLen> key;

    key.Copy(KKeyIndicatorIcon);     

    key.Append(row8);

    PublishImageL(

              iInstIdList[aInstance].iCid,

              contentType,

              key,

              aIcon,

              aIcon + 1,

              mailBoxId,

              KNullDes);

    }

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

// CMailCpsIf::PublishMailboxIconL

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

//

void CMailCpsIf::PublishMailboxIconL( const TInt aInstance,

                                      const TInt aRowNumber, 

                                      const TInt aIcon,

                                      TFSMailMsgId aMailBoxId )

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> row;

    row.Num(aRowNumber);

    TBuf<KMaxDescLen> contentType;

    contentType.Copy(KContTypeMailboxIcons);        

    contentType.Append(row);

    TBuf8<KMaxDescLen> row8;

    row8.Num(aRowNumber);

    TBuf8<KMaxDescLen> key;

    key.Copy(KKeyMailboxIcons);     

    key.Append(row8);

    PublishImageL(

              iInstIdList[aInstance].iCid,

              contentType,

              key,

              aIcon,

              aIcon + 1,

              aMailBoxId,

              KNullDes);

    }

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

// CMailCpsIf::PublishMailboxIconL

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

//

void CMailCpsIf::PublishMailboxIconL( const TInt aInstance, const TDesC& aIconPath )

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> contentType;

    contentType.Copy(KContTypeMailboxIcons);        

    contentType.Append(_L("1"));

    TBuf8<KMaxDescLen> key;

    key.Copy(KKeyMailboxIcons);     

    key.Append(_L8("1"));

    if ( GetWidgetInstanceCount() <= aInstance ) User::LeaveIfError( KErrNotFound );

    PublishIconReferenceL(

        iInstIdList[aInstance].iCid,

        contentType,

        key,

        aIconPath );

    }

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

// CMailCpsIf::PublishIconReferenceL

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

//

void CMailCpsIf::PublishIconReferenceL(

    const TDesC& aContentId,

    const TDesC& aContentType,

    const TDesC8& aKey,

    const TDesC& aIconPath )

    {

    FUNC_LOG;

    CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

    CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

    TLiwGenericParam type( KType, TLiwVariant( KCpData ) );

    inparam->AppendL( type );

    CLiwDefaultMap* pdatamap = CLiwDefaultMap::NewLC();

    CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();

    pdatamap->InsertL( KPublisherId, TLiwVariant( KPubId ) );

    pdatamap->InsertL( KContentType, TLiwVariant( aContentType ) );

    pdatamap->InsertL( KContentId, TLiwVariant( aContentId ) );

    datamap->InsertL( aKey, TLiwVariant( aIconPath ) );

    pdatamap->InsertL( KDataMap, TLiwVariant(datamap) );

    TLiwGenericParam item( KItem, TLiwVariant( pdatamap ) );       

    inparam->AppendL( item );

    iMsgInterface->ExecuteCmdL( KAdd, *inparam, *outparam );

    CleanupStack::PopAndDestroy( datamap );

    CleanupStack::PopAndDestroy( pdatamap );    

    item.Reset();

    type.Reset();

    outparam->Reset();

    inparam->Reset();

    }

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

// CMailCpsIf::PublishMailDetailL

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

//

void CMailCpsIf::PublishMailDetailL( const TInt aInstance,        

                                     const TInt aRowNumber, 

                                     const TDesC& aText,

                                     TWidgetMailDetails aDetail)

    {

    FUNC_LOG;

    TBuf<KMaxDescLen> row;

    row.Num(aRowNumber);

    TBuf<KMaxDescLen> contentType;

    if (aDetail == ETime)

        {    

        contentType.Copy(KContTypeTime);

        }

    else if (aDetail == ESubject)

        {

        contentType.Copy(KContTypeSubjectText);

        }        

    else //aDetail == ESender

        {

        contentType.Copy(KContTypeBodyText);

        }

    contentType.Append(row);

    TBuf<KMaxDescLen> textKey;

    if (aDetail == ETime)

        {

        textKey.Copy(KKeyTime);

        }

    else if (aDetail == ESubject)

        {

        textKey.Copy(KKeySubjectText);

        }     

    else

        {

        textKey.Copy(KKeyBodyText);

        }

    textKey.Append(row);

    TFSMailMsgId mailBoxId;

    TFSMailMsgId folderId;

    iMailboxNameUid = PublishDescriptorL(

        KPubId, contentType, 

        iInstIdList[aInstance].iCid,

        aText,

        textKey, KNullDes8);  

    }

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

// CMailCpsIf::ResetMessageL

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

//

void CMailCpsIf::ResetMessageL( TInt /*aRowNumber*/ )

    {

    FUNC_LOG;

    RemoveL( iMsgUid );

    iMsgUid = 0;

    }

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

// CMailCpsIf::ExtractItemId

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

//

TUint CMailCpsIf::ExtractItemId( 

    const CLiwGenericParamList& aInParamList )

    {

    FUNC_LOG;

    TUint result ( 0 );

    TInt pos( 0 );

    aInParamList.FindFirst( pos, KItemId );

    if ( pos != KErrNotFound )

        {

        // item id present - extract and return

        aInParamList[pos].Value().Get( result ); // indexing should be safe

        }

    return result;

    }

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

// CMailCpsIf::PublishDescriptorL

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

//