/*

* Copyright (c) 2009 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: This file implements class CEmailClientApi.

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <viewclipartner.h>

#include <vwsdefpartner.h>

#else

#include <viewcli.h>

#include <vwsdef.h>

#endif // SYMBIAN_ENABLE_SPLIT_HEADERS

#include "emailclientapiimpl.h"

#include "emailapiutils.h"

#include "emailmailbox.h"

#include <memailaddress.h>

#include "CFSMailPlugin.h"

#include "CFSClientAPI.h"

#include "emailclientapiimpldefs.h"

#include "emailmailboxcache.h"

#include "FreestyleEmailUiConstants.h"

#include "emailclientapi.hrh"

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

// CEmailClientApi::MailboxL

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

//

MEmailMailbox* CEmailClientApi::MailboxL( const TMailboxId& aId )

    {

    UpdateMailboxInfoCacheL();

    CPluginData* pluginData = MailboxInfoCacheL().PluginDataL( aId );

    MEmailMailbox* mailbox = NULL;

    if ( pluginData )

        {

        mailbox = CEmailMailbox::NewL( *pluginData, aId );

        }

    return mailbox;

    }

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

// 

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

MEmailMailbox* CEmailClientApi::MailboxL( const TPtrC& aAddress )

    {

    MEmailMailbox* mailbox = NULL;

    REmailMailboxIdArray mailboxes;

    CleanupClosePushL( mailboxes );

    TInt count( GetMailboxIdsL( mailboxes ) );

    while ( count-- )

        {

        const TMailboxId mailboxId = mailboxes[count];

        MEmailMailbox* refMailbox = MailboxL( mailboxId );

        if ( refMailbox )

            {

            TPtrC address( refMailbox->AddressL()->Address() );

            if ( !address.Compare( aAddress ) )

                {

                mailbox = refMailbox; // addresses match

                count = 0;

                }

            else

                {

                refMailbox->Release();

                }

            }

        }

    CleanupStack::PopAndDestroy();

    // find mailbox or leave KErrNotFound

    if ( !mailbox)

        {

        User::Leave( KErrNotFound );

        }

    return mailbox;

    }

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

// 

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

TInt CEmailClientApi::GetMailboxIdsL( 

    REmailMailboxIdArray& aMailboxes )

    {

    UpdateMailboxInfoCacheL();

    aMailboxes.Reset();

    CEmailMailboxCache& mbcache = MailboxInfoCacheL();

    mbcache.GetIdsL( aMailboxes ); 

    const TInt mailboxesFound( aMailboxes.Count() );

    return mailboxesFound;

    }

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

// 

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

TInt CEmailClientApi::GetMailboxesL( RMailboxPtrArray& aMailboxes )

    {

    REmailMailboxIdArray mailboxIdArray;

    CleanupClosePushL( mailboxIdArray );

    // note! GetMailboxIdsL loads plugin and keeps loaded if it contains at

    // least one mailbox

    TInt count = GetMailboxIdsL( mailboxIdArray );

    while ( count-- )

        {

        // mailbox creation increases plugin ref count by one

        MEmailMailbox* mailbox = MailboxL( mailboxIdArray[count] );

        CleanupReleasePushL( *mailbox );

        aMailboxes.AppendL( mailbox );

        CleanupStack::Pop( mailbox );

        }

    // Created mailboxes still hold plugin references so we can decrease 

    // ref count.

    ReleaseAllPlugins(); 

    CleanupStack::PopAndDestroy(); // mailboxIdArray

    return aMailboxes.Count();

    }

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

// implement this

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

void CEmailClientApi::LaunchEmailL( const TLaunchPolicy aPolicy )

    {

    if ( aPolicy != EDefault )

        {

        // no other launch policies supported

        User::Leave( KErrNotSupported );

        }

    const TUid dummy = {0};

    CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();

    viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, AppGridId),

        dummy, KNullDesC8() );

    CleanupStack::PopAndDestroy();    

    }    

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

// 

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

CPluginData* CEmailClientApi::TPluginIterator::Next()

    {

    CPluginData* item = NULL;

    if ( iIndex < iArray.Count() )

        {

        item = iArray[ iIndex++ ];

        }

    return item;

    }

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

// 

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

CEmailClientApi* CEmailClientApi::NewL()

    {

    CEmailClientApi* self = new ( ELeave ) CEmailClientApi();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// 

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

CEmailClientApi::~CEmailClientApi()

    {

    // ensure this doesn't held plugin references

    ReleaseAllPlugins();

    // ResetAndDestroy doesn't work because ~CPluginData is private

    TInt count( iPluginDataArray.Count() );

    while ( count-- )

        {

        delete iPluginDataArray[count];

        }

    iPluginDataArray.Close();

    iLoadedPluginsArray.Close();

    delete iMailboxCache;

    delete iClientAPI;

    }

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

// 

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

CEmailClientApi::CEmailClientApi()

    {        

    }

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

// 

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

void CEmailClientApi::CleanupImplInfoPushL( RPointerArray<CImplementationInformation>& aArray )

    {

    TCleanupItem item( &CEmailClientApi::CleanupImplInfo, &aArray );

    CleanupStack::PushL( item );

    }

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

// 

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

void CEmailClientApi::CleanupImplInfo( TAny* aAny )

    {

    RPointerArray<CImplementationInformation>* array = 

        reinterpret_cast<RPointerArray<CImplementationInformation>*>( aAny );

    array->ResetAndDestroy();

    }

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

// 

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

void CEmailClientApi::ConstructL()

    {

    RPointerArray<CImplementationInformation> implInfoArray;

    REComSession::ListImplementationsL( KFSMailPluginInterface, implInfoArray );

    CleanupImplInfoPushL( implInfoArray );

    TInt err = KErrNone;

    TInt count( implInfoArray.Count() );

    // add implementation UIDs to plugin info array, no instantiation at this

    // phase

    while ( count-- )

        {

        const CImplementationInformation* info = implInfoArray[count];

        CPluginData* pluginData = new ( ELeave ) CPluginData( info->ImplementationUid() );

        err = iPluginDataArray.Append( pluginData );

        if ( err != KErrNone )

            {

            // failed to append, give up

            delete pluginData;

            count = 0;

            }

        }

    iClientAPI = CFSClientAPI::NewL(this);

    CleanupStack::PopAndDestroy(); // CleanupImplInfoPushL

    User::LeaveIfError( err );    

    }

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

// 

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

TEmailTypeId CEmailClientApi::InterfaceId() const

    {

    return KEmailClientApiInterface;

    }

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

// 

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

void CEmailClientApi::Release()

    {

    delete this;

    }

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

// Returns plugin instance from plugin data. If we already have "claimed"

// instance once, prevent increment of reference count 

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

CFSMailPlugin* CEmailClientApi::UsePlugin( CPluginData& aPluginData )

    {

    // use 'data' as search key for IndexOfLoadedPluginData()

    TPluginData data( aPluginData.Uid() );

    TPluginData* pluginDataPtr = &data;

    // check if we have plugin already "in use".

    const TInt index( IndexOfLoadedPluginData( data ) );

    if ( index == KErrNotFound )

        { // we don't have plugin instance so take it and add to loaded plugins

        data.iPlugin = aPluginData.ClaimInstance();

        if ( data.iPlugin && iLoadedPluginsArray.Append( data ) != KErrNone )

            {                

            aPluginData.ReleaseInstance(); // failed to append, don't proceed..

            data.iPlugin = NULL;           // but return null

            }          

        }

    else

        {

        // already in use, obtain plugin pointer from the array

        pluginDataPtr = &iLoadedPluginsArray[index];

        }

    return pluginDataPtr->iPlugin;

    }

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

// 

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

void CEmailClientApi::ReleasePlugin( CPluginData& aPluginData )

    {

    // release plugin but only if it is not already claimed

    TPluginData data( aPluginData.Uid() );

    const TInt index( IndexOfLoadedPluginData( data ) );

     if ( index != KErrNotFound )

        {

        aPluginData.ReleaseInstance();

        iLoadedPluginsArray.Remove( index );

        }

    }

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

// 

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

void CEmailClientApi::ReleaseAllPlugins()

    {

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

        {

        CPluginData* pdata = iPluginDataArray[i];

        ReleasePlugin( *pdata );

        }

    }

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

// 

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

CEmailMailboxCache& CEmailClientApi::MailboxInfoCacheL()

    {

    if ( !iMailboxCache) 

        {

        iMailboxCache = CEmailMailboxCache::NewL();

        }

    return *iMailboxCache;

    }

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

// Lists all mailboxes in protocol plugins and adds them to cache. Plugins may 

// not be loaded so loading is done. The plugin is kept in memory if it contains

// at least one mailbox to avoid loading again later as typical use case is 

// creation of a mailbox object => the plugin is again needed 

//( see ::GetMailboxesL which calls ReleaseAllPlugins()

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

void CEmailClientApi::UpdateMailboxInfoCacheL()

    {

    CEmailMailboxCache& mbcache = MailboxInfoCacheL();

    if ( !mbcache.IsCached() )

        {

        // cache update needed

        mbcache.StartCachingPushL();

        TPluginIterator iter( iPluginDataArray );

        CPluginData* pluginData = iter.Next();

        while ( pluginData )

            {

            TBool containsMailbox( EFalse );

            // loads plugin if needed

            CFSMailPlugin* plugin = UsePlugin( *pluginData );

            if ( plugin )

                {

                // if one plugin fails, it should not block other plugins

                // ==> trap it             

                TRAPD( err, containsMailbox = CachePluginMailboxesL(

                    *pluginData, 

                    *plugin ) );

                if ( !containsMailbox || err )

                    {

                    // plugins with no mailboxes (or failed to cache) is

                    // released (unloaded) to optimize RAM usage.

                    ReleasePlugin( *pluginData );

                    }            

                }

            else if ( pluginData->iPluginLoadError == KErrNoMemory )

                {

                // don't continue if OOM

                User::Leave( KErrNoMemory );

                }

            pluginData = iter.Next();

            }

        mbcache.EndCachingPop();    

        }    

    }

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

// 

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

TBool CEmailClientApi::CachePluginMailboxesL( CPluginData& aPluginData, CFSMailPlugin& aPlugin )

    {

    TBool containsMailbox( EFalse );

    RArray<TFSMailMsgId> pluginMailboxes;

    CleanupClosePushL( pluginMailboxes );

    aPlugin.ListMailBoxesL( pluginMailboxes );

    TInt mailboxCount = pluginMailboxes.Count();

    while ( mailboxCount-- )

        {

        const TFSMailMsgId& mailboxId = pluginMailboxes[mailboxCount];

        TMailboxId id( mailboxId.Id() );                    

        MailboxInfoCacheL().AddMailboxL( aPluginData, id );

        containsMailbox = ETrue;

        }

    CleanupStack::PopAndDestroy();  // pluginMailboxes

    return containsMailbox;

    }

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

// 

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

TInt CEmailClientApi::IndexOfLoadedPluginData( const TPluginData& aPluginData ) const

    {

    TIdentityRelation<TPluginData> relation( CEmailClientApi::PluginDataEquals );    

    return iLoadedPluginsArray.Find( aPluginData, relation );

    }

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

// 

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

TBool CEmailClientApi::PluginDataEquals( const TPluginData& a1, const TPluginData& a2 )

    {

    return ( a1.iUid == a2.iUid );

    }

CFSMailPlugin* CEmailClientApi::GetPluginByUid(TUid aUid)

    {

    CPluginData *p = NULL;

    CFSMailPlugin* plugin = NULL;

    TRAP_IGNORE( p = iMailboxCache->PluginDataL(aUid) );

    if ( p )

        {

        plugin = p->ClaimInstance();       

        p->ReleaseInstance();

        }

    return plugin;

    }

// End of file.