/*

* 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: Header declaration

*

*/

#ifndef R_SEN_SERVICE_CONNECTION_H

#define R_SEN_SERVICE_CONNECTION_H

// INCLUDES

#include <e32base.h>

#include <flogger.h>

#include "senchunk.h"

#include "senservicemanagerdefines.h" // internal Core\inc  - IPC enumerations

#include "SenServiceConnection.h" 

// FORWARD DECLARE

class CSenSoapEnvelope;

class CSenChunk;

class RFile;

class RSenServiceConnection;

#ifdef __ENABLE_ALR__

class MMobilityProtocolResp;

#endif

class TFourInts

    {

    public:

    	TInt iInt1;

    	TInt iInt2;

    	TInt iInt3;

    	TInt iInt4;

	};

NONSHARABLE_CLASS(CSenProgressResourceHandler): private CActive

    {

    friend class RSenServiceConnection;

    private:

    CSenProgressResourceHandler(TInt aTxnId, TBool aIncoming, TBool aIsSoap,

            TInt aProgress, RSenServiceConnection* aOwner);

    ~CSenProgressResourceHandler();

    void DoCancel();

    void RunL();

    TInt SetBuffer(const TDesC8& aSoapOrCid);

    private:

    TPckgBuf<TTransferProgress> iProgressData;

    HBufC8* iSoapOrCid;

    RSenServiceConnection* iOwner;

    CSenProgressResourceHandler* iNext;

    CSenProgressResourceHandler* iPrevious;

    };

NONSHARABLE_CLASS(CSenConnAgentSync): public CActive

    {

    friend class RSenServiceConnection;

private:

    CSenConnAgentSync();

    ~CSenConnAgentSync();

    void DoCancel();

    void RunL();

    void Start();

    };

// CLASS DECLARATION

class RSenServiceConnection : public RSessionBase

    {

public:

        /**

        * C++ default constructor.

        */

        RSenServiceConnection(RFileLogger* aLog);

        // New functions

        TInt Connect();

        TVersion Version() const;

        void Initialize( TRequestStatus& aStatus, 

        				 TDes8& aErrPtr, 

        				 TDes& aSessionId, 

        				 CSenChunk& aSenChunk,

                         TInt aSdLength,

                         TInt aCpLength,

                         TBool aHasAuthenticationCallback );

        /**

        * Transaction method is asynchronous

        * 

        * @param aStatus is the AO's status

        * @param aErrPtr is where error will be written by server

        * @param aTxnPtr is where transaction ID received from 

        * transport (in the server-side) will be written by server

        * @param aChunk is reference to new chunk, which will be opened

        * RChunk (S60 3rd Edition) or RFile (S60 2nd Edition)

        * @param aChunkName defines the global name for new RChunk (S60 2nd edition)

        * @param aRequest is the message copied into RChunk

        * @return KErrNone or system-wide error code. Note that if

        * an error is returned, then SendReceive has not been called

        * and caller (SC implementation class) does not need to call 

        * SetActive()

        */

        void Transaction(TRequestStatus& aStatus, 

                         TDes8& aErrPtr, 

                         TDes8& aTxnPtr, 

                         CSenChunk& aClientOp);

        TInt SendMsgAndReceiveTxnId(CSenChunk& aClientOp);

        TInt IsReady(TBool& aReady);

        TInt HasFacet(TDesC8& aUri, TBool& aHasFacet);

        TInt CompleteServerMessagesOnOff( TBool& aOnOff );

        void SetLog(RFileLogger* aLog);

        TInt RequestServiceDescription(TDes8& aSdLength);

        TInt ReceiveServiceDescription(TDes8& aServiceDescription);

        TInt StartTransaction();

        TInt TransactionCompleted();

        void CancelSession(TRequestStatus& aStatus);

        void CancelRequests(TRequestStatus& aStatus);

        void CancelRequest(TInt aTransactionID);

   	    void DataTrafficDetails(TSenDataTrafficDetails& aDetails,TSenDataTrafficOperations& aOperation);  

        TInt SetTransportPropertiesL(CSenChunk& aSenChunk);

        TInt TransportPropertiesL(CSenChunk& aSenChunk);        

        TInt MoveFile(CSenChunk& aSenChunk, 

                      const TDesC8& aCid, 

                      RFile& aFile);

        TInt SendFileHandle(CSenChunk& aSenChunk, 

                      		RFile& aFile);

        TInt MoveChunk(CSenChunk& aSenChunk, 

                       const TDesC8& aCid, 

                       RChunk& aChunk,

                       TInt aDataOffset, 

                       TInt aDataSize);

        TInt ConnectionID();

        TInt IdentityProviderL(CSenChunk& aSenChunk);

        TInt RegisterIdentityProvider(TDesC8& aMessage);

        void SetChannel(TInt aChannel);

        TInt RegisterTransferObserver(const TDesC* aServerName, TAny* aConnection);

        // @return KErrNoMemory if out of heap

        TInt SendFileProgress( TInt aTxnId, TBool aIncoming,TBool aIsSoap,

                               const TDesC8& aSoapOrCid, TInt aProgress );

        void Remove(CSenProgressResourceHandler* aResourceHandler);

        void Close();

        TInt SearchIdentityProviderL(CSenChunk& aSenChunk, const TDesC8& aProviderId);

        TInt RegisterAuthenticationObserver(const TDesC* aServerName, TAny* aConnection);

        TInt RegisterCoBrandingObserver(const TDesC* aServerName, TAny* aConnection);

#ifdef __ENABLE_ALR__

	    TInt RegisterMobilityObserverL(const TDesC* aServerName, TAny* aConnection) ;

	    TInt MigrateToPrefferedCarrierL(TBool &aUserChoice) ;

	    TInt NewCarrierAcceptedL(TBool &aUserChoice) ;

#endif

    private: // Helper functions

        RFileLogger* Log() const;

    private: // Data

        TInt                iMessageContextId; // locally (in SC scope) unique message context ID counter

        RFileLogger*        iLog;

        TPckgBuf<TFourInts> iFourInts;

        CSenProgressResourceHandler* iFirst;

        TInt                iTLSLogChannel;

    };

#endif //R_SEN_SERVICE_CONNECTION_H