/*

* 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:  Metadata for ATEXT

*

*/

#ifndef C_CATEXTMETADATA_H

#define C_CATEXTMETADATA_H

#include <e32base.h>

#include <atext.h>

#include "atextpluginobserver.h"

class CATExtPluginBase;

class CATExtListen;

/** Panic categories */

enum TATExtPanicCategories

    {

    };

/**  Support types supported by RSS file (M|P|O) */

enum TATExtSupportType

    {

    ESupportTypeUndefined = KErrNotFound,

    ESupportTypeMaster    = 0,

    ESupportTypePartial,

    ESupportTypeObserver

    };

/**  Operation types, either for command handling or for URC receiving */

enum TATExtOperationType

    {

    EOperationUndefined     = KErrNotFound,

    EOperationHandleCommand = 0,

    EOperationReceiveUrc

    };

/**

 *  Completion information for CATExtSession::IpcHandleCommand().

 *  This data is needed to check how the AT command handling succeeded and what

 *  was the type of the completed AT command (in HandleCommand()).

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( TATExtCompletionInfo )

    {

public:

    /**

     * Flag to indicate whether or not an AT command was processed by some

     * plugin

     *

     */

    TBool iProcessed;

    /**

     * Flag to indicate whether or not a reply is expected from some of the

     * plugins

     */

    TBool iReplyExpected;

    };

/**

 *  Class to store data needed by each plugin.

 *  Support data TATExtAtCmdSupport creates links to one plugin entry.

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( TATExtPluginEntry )

    {

public:

    /**

     * UID of plugin with support

     */

    TUid iPluginUid;

    /**

     * Instance of plugin

     */

    CATExtPluginBase* iInstance;

    /**

     * Flag to indicate whether or not the access to plugin data is locked

     */

    TBool iLocked;

    /**

     * Flag to indicate whether or not URC message receiving has started

     */

    TBool iUrcStarted;

    /**

     * Client request message for URC message receiver

     */

    RMessage2 iUrcMessage;

    /**

     * Flag to indicate whether or not the plugin URC handling is owned by the

     * client side user.

     */

    TBool iUrcOwned;

    };

/**

 *  Search helper information for AddNewMetadataEntryLinkL().

 *  The data in this class is changes when the indexes are known.

 *  When known index(es) are found then these indexes are used instead of

 *  searching for the position where to insert the new entry. Index for master

 *  entry is not stored as it is always inserted as the first entry.

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( TATExtSearchHelper )

    {

public:

    TATExtSearchHelper() : iPartialIndex( KErrNotFound ),

                           iObserverIndex( KErrNotFound ) {}

    /**

     * Index to the partial entry

     */

    TInt iPartialIndex;

    /**

     * Index to the observer entry

     */

    TInt iObserverIndex;

    };

/**

 *  Class to store data needed for one AT command support.

 *  This includes the support's type and the plugin entry.

 *  Thus one plugin's RSS file may contain multiple M|P|O entries.

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( TATExtOneCmdSupport )

    {

public:

    /**

     * Support's type (M|P|O)

     */

    TATExtSupportType iSupportType;

    /**

     * Plugin entry for support

     */

    TInt iEntryIndex;

    };

/**

 *  Class to store data needed for one AT command.

 *  Links to entry data TATExtPluginEntry are added for each supported AT

 *  command. Each entry of TATExtAtCmdSupport specifies the entry entered to

 *  an RSS file's "default_data" field with the "=" and the substring after it

 *  truncated. The truncation is done by CreateAndFindSupportL().

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( TATExtAtCmdSupport )

    {

public:

    /**

     * Supported AT command

     */

    HBufC8* iAtCmdBase;

#if defined( PRJ_OPTIMIZE_FOR_SPEED )

    /**

     * Search helper to iEntries. Needed when creating the database.

     */

    TATExtSearchHelper iSearchHelper;

#endif

    /**

     * Plugin entries for support

     */

    CArrayFixFlat<TATExtOneCmdSupport>* iEntries;

    };

/**

 *  Cleanup information for AddEntryToMetadataL().

 *  This data is needed to clean up partially constructed data in

 *  HandleCommand() when a leave occurs in plugin entry or support entry

 *  addition.

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( TATExtCleanupInfo )

    {

public:

    /**

     * Flag to indicate whether or not a support entry was created

     */

    TBool iSupportCreated;

    /**

     * Index to the position where the support entry was inserted

     */

    TInt iSupportIndex;

    /**

     * Flag to indicate whether or not a plugin entry was created

     */

    TBool iEntryCreated;

    /**

     * Index to the position where the entry was inserted

     */

    TInt iEntryIndex;

    /**

     * Support information to normal or auxiliary plugin data

     */

    CArrayFixFlat<TATExtAtCmdSupport>* iSupport;

    };

/**

 *  Class to store data related to AT command handling.

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( TATExtCommandData )

    {

public:

    /**

     * Flag indicating whether or not command handling has started

     */

    TBool iCmdStarted;

    /**

     * Flag indicating whether or not reply expected from plugin to ATEXT.

     * This is used to omit HandleCommandCompleted() from a plugin to ATEXT

     * when ATEXT uses its own reply.

     */

    TBool iReplyExpected;

    /**

     * Client request message for AT command handling

     */

    RMessage2 iCmdMessage;

    /**

     * Buffer for command.

     * Set by HandleCommand().

     */

    RBuf8 iCmdBuffer;

    /**

     * Buffer for reply.

     * Set by CompleteCommandMessage() and GetNextPartOfReply().

     */

    RBuf8 iCmdReplyBuffer;

    /**

     * Plugin entry for the AT command handler

     * Not own.

     */

    TATExtPluginEntry* iHandler;

    /**

     * Plugin entry for the AT command handler (old command handled);

     * set when command handling successfully completed.

     * Not own.

     */

    CATExtPluginBase* iOldHandler;

    };

/**

 *  Class store data for AT command handling.

 *  This is basically a helper class for internal usage to pass around data

 *  related to AT command handling.

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( TATExtEntrySupport )

    {

public:

    TATExtEntrySupport( TDesC8& aAtCmdFull,

                        const RMessage2& aMessage,

                        CArrayFixFlat<TATExtOneCmdSupport>* aSupport ) :

                        iAtCmdFull( aAtCmdFull ),

                        iMessage( aMessage ),

                        iSupport( aSupport ),

                        iEntry( NULL ),

                        iStartIndex( KErrNotFound ),

                        iSupportFound( EFalse ){}

    /**

     * Full AT command for which to check the support

     * (base part + parameters)

     */

    TDesC8& iAtCmdFull;

    /**

     * Client request message for reading

     */

    const RMessage2& iMessage;

    /**

     * AT command's plugin entry support data.

     * Used by SendToMultipleObserverL() and FindFirstObserverSupportL().

     */

    CArrayFixFlat<TATExtOneCmdSupport>* iSupport;

    /**

     * Found plugin entry.

     */

    TATExtPluginEntry* iEntry;

    /**

     * Start index for searches with HandlePartialAndMasterPluginSupportL() and

     * HandleObserverPluginSupportL()

     */

    TInt iStartIndex;

    /**

     * Found plugin support for HandlePartialAndMasterPluginSupportL().

     */

    TBool iSupportFound;

    };

/**

 *  Class for handling various operations of the server session which are

 *  related to metadata handling. Also adds methods which don't do metadata

 *  handling but are better to be in this class for abstraction and data hiding

 *  reasons.

 *

 *  @since S60 v5.0

 */

NONSHARABLE_CLASS( CATExtMetadata ) : public CBase

    {

public:

    /**

     * Two-phased constructor.

     * @param aEComSession ECOM session; used for getting ECOM implementation

     *                     information.

     * @param aListener ECOM plugin notification event listener

     * @param aObserver Plugin observer (needed for instantiation)

     * @return Instance of self

     */

	static CATExtMetadata* NewL( REComSession& aEComSession,

                                 CATExtListen* aListener,

                                 MATExtPluginObserver& aObserver );

    /**

     * Two-phased constructor.

     * @param aEComSession ECOM session; used for getting ECOM implementation

     *                     information.

     * @param aListener ECOM plugin notification event listener

     * @param aObserver Plugin observer (needed for instantiation)

     * @return Instance of self

     */

    static CATExtMetadata* NewLC( REComSession& aEComSession,

                                  CATExtListen* aListener,

	                              MATExtPluginObserver& aObserver );

    /**

    * Destructor.

    */

    virtual ~CATExtMetadata();

    /**

     * Resets data to initial values

     *

     * @since S60 5.0

     * @return None

     */

    void ResetData();

    /**

     * Creates new implementation metadata based on a given interface UID and

     * connection. Uses AddImplementationL() to add new implementations for the

     * interface and sets connection identification name for reporting it to the

     * plugins on instantiation time.

     *

     * @since S60 5.0

     * @param aIfUid Interface UID to support

     * @param aName Connection identification name

     * @return None

     */

    void CreateImplementationMetadataL( TUid& aIfUid, const TDesC8& aName );

    /**

     * Adds an implementation to the metadata based on a given ECOM

     * implementation information. This is used by the function

     * CreateImplementationMetadataL() and also by CATExtSession when its ECOM

     * notification listener detects an addition for a the same ECOM interface.

     * This function uses DoAddImplementation to add the actual AT command set

     * to the metadata.

     *

     * @since S60 5.0

     * @param aImplInfo ECOM implementation information from which to create new

     *                  metadata

     * @return None

     */

    void AddImplementationL( CImplementationInformation* aImplInfo );

    /**

     * Removes an implementation from the support data by a given plugin UID.

     *

     * @since S60 5.0

     * @param aPluginUid Plugin UID to search from plugin data

     * @param aInstanceExists ETrue if instance exists, EFalse otherwise

     * @return Symbian error code on error, KErrNone otherwise

     */

    TInt RemoveImplementation( TUid& aPluginUid, TBool aInstanceExists=ETrue );

    /**

     * Handles an AT command

     *

     * @since S60 5.0

     * @param aMessage Client request message for reading

     * @param aComplInfo Completion information for the handled command

     * @return Symbian error code on error, KErrNone otherwise

     */

    TInt HandleCommand( const RMessage2& aMessage,

                        TATExtCompletionInfo& aComplInfo );

    /**

     * Cancels an active handle command operation. Uses IsCommandHandling() and

     * CancelCommandOperation().

     *

     * @since S60 5.0

     * @return Symbian error code on error, KErrNone otherwise

     */

    TInt CancelHandleCommand();

    /**

     * Gets the next part of a reply for HandleCommand().

     * Length of returned reply must be the same as the one reported

     * from NextReplyPartLength() for the current reply.

     *

     * @since S60 5.0

     * @param aMessage Client request message for reading

     * @return Symbian error code on error, KErrNone otherwise

     */

    TInt GetNextPartOfReply( const RMessage2& aMessage );

    /**

     * Completes an URC processing message by a given plugin UID.

     * Completion code for the client message is the return code from a

     * write with WriteReplyBufferToClient()

     *

     * @since S60 5.0

     * @param aAtCmd URC message to write to the client side

     * @param aPlugin Plugin UID to search from plugin data

     * @return Symbian error code on error, KErrNone otherwise

     */

    TInt CompleteUrcMessage( const TDesC8& aAtCmd,

                             CATExtPluginBase* aPlugin );

    /**

     * Completes an AT command handling message. Also clears internal

     * initialized command hanlder data; see ClearInitializedCmdHandlerData().

     *

     * @since S60 5.0

     * @param aPlugin Plugin's instance to match against the command data

     *                NULL if no check wanted for a match against the command

     *                data

     * @param aError Completion error code for the command message

     * @param aErrorReply ETrue if error reply "ERROR" needed,

     *                    EFalse if empty reply "" needed.

     *                    For "" and "ERROR" replies the reply must not

     *                    contain an existing reply

     * @param aReplyType Reply type for the handled AT command

     * @param aMultiPart ETrue (default behavior) if multipart reply wanted,

     *                   EFalse otherwise.

     *                   For multipart replies the reply may be over

     *                   KDefaultCmdBufLength.

     * @return Symbian error code on error, KErrNone otherwise

     */

    TInt CompleteCommandMessage( CATExtPluginBase* aPlugin,

                                 TInt aError,

                                 TBool aErrorReply,

                                 TATExtensionReplyType aReplyType,

                                 TBool aMultiPart );

    /**

     * Clears internal initialized command handler data. This is currently used