/*

* Copyright (c) 2002-2005 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:           Custom plug-in implementations offer their own API documentation

*                where detailed characteristics about how methods declared in this

*                class are implemented.

*

*/

#ifndef SEN_HOSTLET_CONNECTION_IMPL_H

#define SEN_HOSTLET_CONNECTION_IMPL_H

// INCLUDES

#include <e32property.h>

#include <flogger.h>

#include "SenHostletConnection.h"   // public 

#include "rsenhostletconnection.h"

#include "senpointermap.h"

#include "senlogger.h"

#include "sendebug.h"

#include "senregistrationtimer.h"

// FORWARD DECLARATIONS

class MSenHostlet;

class MSenHostletRequest;

class MSenHostletResponse;

//class MSenServiceDescription;

class CSenChunk;

class CSenAsyncOperation;

class CSenHostletTransaction;

class CSenIdentifier;

class CSenHostletRequest;

class CSenHostletResponse;

class CSenFileProgressObserver;

// TYPEDEFS

typedef RSenPointerMap<TInt, CSenHostletTransaction> RHostletTransactionMap;

// CLASS DECLARATION

/**

* Custom plug-in implementations offer their own API documentation

* where detailed characteristics about how methods declared in this

* class are implemented.

*/

class CSenHostletConnectionImpl : public CSenHostletConnection, MSenRegistrationActor

    {

        friend class CSenAsyncOperation;

    public: 

        // Constructors and destructor:

        static CSenHostletConnectionImpl* NewL(MSenHostlet& aProvider);

        static CSenHostletConnectionImpl* NewLC(MSenHostlet& aProvider);

        virtual ~CSenHostletConnectionImpl();

        // New functions:

        virtual TInt RespondL(MSenHostletResponse& aResponse);

        virtual TInt Identifier();

    protected: // Functions from base classes 

        // from CActive

        void RunL();

        void DoCancel();

    private:

        /**

        * C++ default constructor.

        */

        CSenHostletConnectionImpl(MSenHostlet& aProvider);

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        // New functions

        TInt EstablishConnectionL(MSenHostlet& aProvider);

        TInt RegisterAndSubscribeFileProgressObserversL();

        // Utility functions:

        RHostletTransactionMap& HostletTransactionMapL();

        TPtrC SessionID();

        RPointerArray<CSenAsyncOperation>& AsyncOpsArrayL();

        void HandleErrorFromChildAOL(TInt aError, TInt aTxnId, const TDesC8& aDesc, CSenAsyncOperation& aChild);

        void HandleMessageFromChildAOL(TInt aStatus, CSenAsyncOperation& aChild);

        TInt RegisterFilesObserver();

    private: // Data

        RSenHostletConnection iConnection;  // owned

        MSenHostlet& iProvider;             // not owned

        TInt    iResponseLength;

        TInt    iErrorNumber;

        TPtr8   iErrorNumberBuffer;

        TInt    iTxnId;

        TPtr8   iTxnIdBuffer;

        RHostletTransactionMap* iHostletTransactionMap;

        HBufC* ipSessionId;

        TPtr iSessionIdBuffer;

        TInt iChunkNameNumber;

        HBufC* ipChunkName;

        TBool iAlive;

        TBool iTransactionIdKnown;

        TUint iAsyncOpsCount;

        RPointerArray<CSenAsyncOperation>* iAsyncOpsArray;

        TInt iConnectionID;

        MSenFilesObserver*                  iFilesObserver;

        TInt iTlsLogChannel;

        TAny*                               ipInterface;

        TBool 								iCancelSession;

        CSenFileProgressObserver*			ipFileProgressObserver; // owned

        TBool iRegisterFileObserverDone;

        CSenRegistrationTimer*              ipRegistrationTimer;

    };

#ifdef EKA2

NONSHARABLE_CLASS(CSenAsyncOperation) : public CActive

#else

class CSenAsyncOperation : public CActive 

#endif

    {

    public: // Constructors and destructor

        static CSenAsyncOperation* NewL(CSenHostletConnectionImpl* aActive);

        static CSenAsyncOperation* NewLC(CSenHostletConnectionImpl* aActive);

        virtual ~CSenAsyncOperation();

    protected: // Functions from base classes 

        // from CActive

        void RunL();

        void DoCancel();

        TInt RunError(TInt aError);

    private:

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        CSenAsyncOperation(CSenHostletConnectionImpl* iActive);

    public: // Data

        CSenHostletConnectionImpl* iActive;

        TInt    iErrorNumber;

        TPtr8   iErrorNumberBuffer;

        TInt    iTxnId;

        TPtr8   iTxnIdBuffer;

    };    

#ifdef EKA2

NONSHARABLE_CLASS(CSenHostletTransaction) : public CBase

#else

class CSenHostletTransaction : public CBase 

#endif

    {

    public: // Constructors and destructor

        static CSenHostletTransaction* NewL(CSenChunk* aSenChunk);

        static CSenHostletTransaction* NewLC(CSenChunk* aSenChunk);

        virtual ~CSenHostletTransaction();

        void SetChunk(CSenChunk* aChunk);

        CSenChunk* Chunk();

        void SetIdentifier(CSenIdentifier* aIdentifier);

        CSenIdentifier* Identifier();

        void SetRequest(CSenHostletRequest* aRequest);

        CSenHostletRequest* Request();

        void SetResponse(CSenHostletResponse* aResponse);

        CSenHostletResponse* Response();

    private:

        CSenHostletTransaction(CSenChunk* aSenChunk);

    private: // Data

        CSenChunk*              iSenChunk;

        CSenIdentifier*         iIdentifier;

        CSenHostletRequest*     iRequest;

        CSenHostletResponse*    iResponse;

    };    

#ifdef EKA2

NONSHARABLE_CLASS(CSenFileProgressObserver) : public CActive

#else

class CSenFileProgressObserver : public CActive

#endif

    {

    public:

        static CSenFileProgressObserver* NewL( MSenFilesObserver& aObserver,

                                               TInt aConnectionID );

        static CSenFileProgressObserver* NewLC( MSenFilesObserver& aObserver,

                                                TInt aConnectionID );

        ~CSenFileProgressObserver();

    private:

        CSenFileProgressObserver( MSenFilesObserver& aObserver,

                                  TInt aConnectionID );

        void ConstructL();

         /*

        * Method update the consumer about the file progress transfer info

        */

        void RunL();

        void DoCancel();

        TInt RunError(TInt aError);

    private:

        RProperty                   iFileProgressProperty;

        MSenFilesObserver*        	iFileProgressObserver;        // not owned

        TInt                        iConnectionID;

    };    

#endif //SEN_HOSTLET_CONNECTION_IMPL_H

// End of File