/*

* 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: Definition of Email API main interface.

*

*/

#ifndef EMAILCLIENTAPIIMPL_H

#define EMAILCLIENTAPIIMPL_H

#include <ecom/implementationinformation.h> 

#include "emailapiutils.h"

#include "cfsmailcommon.h"

#include "mfsmaileventobserver.h"    

#include <memailclientapi.h>

#include "emailclientpluginmanager.h"

using namespace EmailInterface;

class CFSMailBox;

class MEmailEventObserver;

class CVwsSessionWrapper;

class CFSMailPlugin;

class TFSMailMsgId;

class CEmailMailboxCache;

class CFSClientAPI;

/**

*  "Framework" class including plugin management

* @since S60 v5.2

*/

NONSHARABLE_CLASS( CEmailClientApi ) : public CBase, public MEmailClientApi, public MEmailClientPluginManager

{

public:

    /**

    * Constructor

    * @return

    */

    static CEmailClientApi* NewL();

    /**

     * Destructor

     */

    ~CEmailClientApi();

    /**

     *

     */

     CEmailClientApi();       

public: // from MEmailInterface

    virtual TEmailTypeId InterfaceId() const;

    virtual void Release();

public: // from MEmailClientApi

    /** @see MEmailClientApi */   

    virtual MEmailMailbox* MailboxL( const TMailboxId& aId );

    /** @see MEmailClientApi */   

    virtual MEmailMailbox* MailboxL( const TPtrC& aAddress );

    /**

    * Gets all mailboxes in pointer array. It is recommended to free other

    * mailboxes besides needed one to optimise memory usage.

    */    

    virtual TInt GetMailboxesL( RMailboxPtrArray& aMailboxes );

    /**

    */

    virtual void LaunchEmailL( const TLaunchPolicy aPolicy );

public: // from MEmailPluginManager

    virtual CFSMailPlugin* GetPluginByUid(TUid aUid);    

public: // new methods

    /**

     * Gets array of mailbox ids

     * @param aMailboxes mailbox ids from all plugins

     * @return number of mailboxes returned in aMailboxes

     */

    TInt GetMailboxIdsL( REmailMailboxIdArray& aMailboxes );

private:

    /**

     * Constructor

     */

    void ConstructL();

    /**

     * Push ECom implementation info to cleanup operation to cleanup stack

     */

    void CleanupImplInfoPushL( RPointerArray<CImplementationInformation>& aArray );

    /**

     * Cleanup operation for ECom implementation info

     */

    static void CleanupImplInfo( TAny* aAny );

    // Group of methods for book keeping of loaded protocol plugins by this object.

    // In certain situations it is preferable to have a plugin in memory

    // instead of loading/unloading frequently.

    /** Increases plugin reference count if CEmailClientApi already doesn't

     *  have active instance. When plugin is needed internally, this method

     * should be accessor to a plugin. Counterpart is ReleasePlugin() when

     * CEmailClientApi doesn't itself need plugin any more.

     */

    CFSMailPlugin* UsePlugin( CPluginData& aPluginData );

    /**

    * For finding plugin data

    */

    TInt IndexOfLoadedPluginData( const TPluginData& aPluginData ) const;

    /**

    * Used in comparing plugin data in array (part of find algorithm)

    */    

    static TBool PluginDataEquals( const TPluginData& a1, const TPluginData& a2 );

    /**

    * This object doesn't need related protocol plugin

    */

    void ReleasePlugin( CPluginData& aPluginData );

    /**

    * This object doesn't need any protocol plugin

    */

    void ReleaseAllPlugins();

    /**

    * Return mailbox cache, creates it when called first time

    */

    CEmailMailboxCache& MailboxInfoCacheL();

    /**

    * Caches mailbox ids and their mapping to related plugin data for quick

    * lookup. When a mailbox with specific id is next time asked, related

    * protocol plugin is already known.

    */

    void UpdateMailboxInfoCacheL();

    /**

    * Internal, used from UpdateMailboxInfoCacheL

    */    

    TBool CachePluginMailboxesL( 

        CPluginData& aPluginData, 

        CFSMailPlugin& aPlugin );

private:    

    typedef RPointerArray<CPluginData> RPluginDataArray;

    /**

    * Iterator for CPluginData elements in an array

    */

    class TPluginIterator

    {

    public:

        // constructor

        inline TPluginIterator( RPluginDataArray& aArray ) : 

            iArray( aArray ), iIndex( 0 ) {}

        /**

        * return next element

        */

        CPluginData* Next();

    private:

        // iterator array

        RPluginDataArray& iArray;

        // current iterator index

        TInt iIndex;

    };

#if 0 // Not supported    

    /**

     * Internal helper class for handling events related to mailboxes

     *(adding/removal/rename).

     */

    class CObserverHandler : public CBase, public MFSMailEventObserver

    {

    public:

        static CObserverHandler* NewL( const RPluginDataArray& aArray  );

        ~CObserverHandler();

        CObserverHandler( const RPluginDataArray& aArray );

        void ConstructL();

        void AddObserverL( MMailboxEventObserver& aObserver );

        void RemoveObserver( MMailboxEventObserver& aObserver );

    public: // from MFSMailEventObserver

        virtual void EventL(TFSMailEvent aEvent, TFSMailMsgId aMailbox, TAny* aParam1, TAny* aParam2, TAny* aParam3);

    private: // new methods

        // used for finding oberver

        static TBool Equals( const MMailboxEventObserver& a1, const MMailboxEventObserver& a2 );

        // Plugins needed when first observer subscribes events

        void ClaimPluginsAndStartObservingL();

        // plugins can be released when last observer removed

        void ReleasePlugins();

    private: // data

        // Plugin refCount is incremented by one while any observer is 

        // registered. This prevents plugin unloading if no other entity uses 

        // the plugin. 

        class TEntry

        {

        public:

            inline TEntry( CPluginData& aData ) : iData( aData ), iPlugin( NULL ) {}

            CPluginData& iData;    

            // claimed from same object where iData refers to

            CFSMailPlugin* iPlugin;

        };

        // plugin entry array

        RArray<CObserverHandler::TEntry>     iEntryArray;

        // reference to CEmailClientApi::iPluginDataArray

        const RPluginDataArray&              iPluginDataArray;

        // registered observers

        RPointerArray<MMailboxEventObserver> iMailboxObservers;

    };

#endif    

    /**

     * Returns reference to observer handler.

     */

#if 0 // Not supported    

    CEmailClientApi::CObserverHandler& ObserverHandlerL();

#endif    

private:

    // plugin data array for all protocol plugins

    RPluginDataArray    iPluginDataArray;

    // book keeping of loaded plugins

    RArray<TPluginData> iLoadedPluginsArray;

#if 0 // Not supported    

    // orchestrates event monitoring and related plugin references

    CEmailClientApi::CObserverHandler*   iObserverHandler;

#endif

    // Mailbox ids are cached when first time listed. Related plugin uid

    // is include in the cache.

    CEmailMailboxCache* iMailboxCache;

    CFSClientAPI* iClientAPI;

};

/**

* Email application launcher. 

*/

NONSHARABLE_CLASS( CEmailLauncher ) : public CBase

{

public:

    static CEmailLauncher* NewL();

    ~CEmailLauncher();

    /**

    *

    */

     void LaunchL( const TMailboxId& aMailboxId );

private:

    CEmailLauncher();

    void ConstructL();

    // Owned window server session.

    CVwsSessionWrapper* iViewSrvSession;

};

#endif // EMAILCLIENTAPIIMPL_H

// End of file.