/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Main class for client side request handling.

 *

*/

#include "FeedsServerMsg.h"

#include "Transaction.h"

#include "FeedsEntity.h"

#include "FeedsInterface.h"

#include <S32Mem.h>

#include <es_sock.h>

#include "FeedsMap.h"

#include "Packed.h"

#include "PackedFeed.h"

#include "PackedFolder.h"

#include "Logger.h"

const TInt KSettingsBufSize = 50;

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

// CFeedsMap::NewL

//

// Two-phased constructor.

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

//

CTransaction* CTransaction::NewL(MTransactionObserver& aObserver, TInt aUniqueId,

        TInt aFolderListId)

    {

    CTransaction * self = NewLC(aObserver,aUniqueId,aFolderListId);

    CleanupStack::Pop(self);

    return self;

    }

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

// CTransaction::NewLC

//

// Two-phased constructor.

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

//

CTransaction* CTransaction::NewLC(MTransactionObserver& aObserver, TInt aUniqueId,

        TInt aFolderListId)

    {

    CTransaction * self = new (ELeave) CTransaction(aObserver,aUniqueId,aFolderListId);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CTransaction::CTransaction

//

// C++ default constructor can NOT contain any code, that

// might leave.  

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

//

CTransaction::CTransaction(MTransactionObserver& aObserver,TInt aUniqueId,TInt aFolderListId):

CActive(EPriorityStandard), iObserver(aObserver), iRequestBuffPtr(NULL, 0),

iFolderListId(aFolderListId),iNotifyOnCancel(ETrue),iId(aUniqueId),iServerResponseTypePkg(iServerResponseType),

iResponsePtr(NULL, 0),iResponseEntryIdPkg(iResponseEntryId)

    {

    }

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

// CTransaction::ConstructL

//

// Symbian 2nd phase constructor can leave.  

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

//

void CTransaction::ConstructL()

    {

    CActiveScheduler::Add (this);

    iRequestBuff = CBufFlat::NewL (128);

    iSettingsResponseBuffer = CBufFlat::NewL (128);

    iAutoDelete = CIdle::NewL (CActive::EPriorityIdle);

    }

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

// CTransaction::~CTransaction

//

// Deconstructor.  

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

//

CTransaction::~CTransaction()

    {

    delete iFeedsEntity;

    delete iResponseBuffer;

    delete iPacked;

    iNotifyOnCancel = EFalse;

    Cancel ();

    delete iRequestBuff;

    delete iAutoDelete;

    delete iFeedsEntity;

    delete iSettingsResponseBuffer;

    }

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

// CTransaction::DoCancel

//

// Implements cancellation of an outstanding request.

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

//

void CTransaction::DoCancel()

    {

    // iNotifyOnCancel is set to false in the destructor.  

    // A virtual method, RequestCompletedL(),

    // that is implemented in a subclass can't be called through the destructor of the parent class.

    if ( iNotifyOnCancel)

        {

        TRAPD( err, RequestCompletedL(KErrCancel) )

        ;

        if ( err != KErrNone)

            {

            }

        }

    }

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

// CTransaction::RunL

//

// Handles an active object's request completion event.

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

//

void CTransaction::RunL()

    {

    RequestCompletedL (iStatus.Int ());

    }

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

// CTransaction::RunError

//

// Handles an active object's errors.

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

//

TInt CTransaction::RunError(TInt aError)

    {

    TRAPD( err, RequestCompletedL(aError) );

    return err;

    }

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

// CTransaction::Start

//

// Starts the handler.  

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

//

void CTransaction::Start()

    {

    SetActive ();

    }

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

// CTransaction::AutoDelete

//

// Starts an CIdle to delete the instance after the callstack has unrolled.

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

//    

EXPORT_C void CTransaction::AutoDelete()

    {

    iAutoDelete->Start (TCallBack (DelayedDelete, this));

    }

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

// CTransaction::DelayedDelete

// 

// Deletes the instance after the callstack has unrolled.

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

//

TInt CTransaction::DelayedDelete(TAny* aPtr)

    {

    CTransaction* self = static_cast<CTransaction*>(aPtr);

    delete self;

    return EFalse;

    }

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

// CTransaction::Type

// 

// Returns the handler's type.

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

//

EXPORT_C  CTransaction::TTransactionType CTransaction::Type()

    {

    return iType;

    }

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

// CTransaction::DebugPrintTables

//

// Print tables of database.

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

//

void CTransaction::DebugPrintTables()

    {    

    // Set the request type.

    iType = EPrintDBTables;

    iObserver.SendAsyncCommand(EFeedsServerPrintDBTables, 

            TIpcArgs(), iStatus);

    Start();

    }

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

// CTransaction::DisconnectManualUpdateConnection

//

// Disconnect connection provided by client for manual update.

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

//

void CTransaction::DisconnectManualUpdateConnection()

    {

    // Set the request type.

    iType = EDisconnectManualUpdateConnection;

    iObserver.SendAsyncCommand (EFeedsServerDisconnectManualUpdateConnection,

            TIpcArgs (), iStatus);

    Start ();

    }

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

// CTransaction::ChangeServerSettingsL

//

// Handles the upating of a the feeds server settings.

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

//

void CTransaction::ChangeServerSettingsL(const TFeedsServerSetting& aNewSetting)

    {

    // Set the request type.

    iType = EChangeSettings;

    RBufWriteStream  stream;

    // Package the request.

    stream.Open(*iRequestBuff);

    CleanupClosePushL(stream);

    // Write out the settings.  

    // NOTE: Be sure to adjust KSettingsBufSize if more settings are added.

    // TODO: Also write out a version number -- do this with all R-Class messages.

    stream.WriteInt32L( iFolderListId );    

    stream.WriteUint8L(aNewSetting.iAutoUpdate);    

    stream.WriteUint16L(aNewSetting.iAutoUpdateFreq);    

    stream.WriteUint32L(aNewSetting.iAutoUpdateAP);

    stream.WriteUint8L(aNewSetting.iAutoUpdateWhileRoaming);

    iRequestBuff->Compress();

    CleanupStack::PopAndDestroy(/*stream*/);

    // Make the request.

    iRequestBuffPtr.Set (iRequestBuff->Ptr(0).Ptr (), iRequestBuff->Size ());

    iObserver.SendAsyncCommand (EFeedsServerChangeSettings,

        TIpcArgs (&iRequestBuffPtr), iStatus);

    Start ();

    }

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

// CTransaction::WatchSettingsL

//

// Sets up a notifier to execute when the settings change.

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

//

void CTransaction::WatchSettingsL()

	{

	RBufWriteStream stream;

	// Set the request type.

	iType = EWatchForSettingChanges;

	// Package the request.

	stream.Open (*iRequestBuff);

	CleanupClosePushL (stream);

	// Write out the folder list id.

	stream.WriteInt32L (iFolderListId);

	iRequestBuff->Compress ();

	CleanupStack::PopAndDestroy (/*stream*/);

	// Make the request.

	iRequestBuffPtr.Set (iRequestBuff->Ptr(0).Ptr (), iRequestBuff->Size ());

	iObserver.SendAsyncCommand (EFeedsServerWatchSettings,

        TIpcArgs (&iRequestBuffPtr), iStatus);

    Start ();

    }

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

// CTransaction::FetchServerSettingsL

//

// Handles the fetching of the feeds server settings.

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

//

void CTransaction::FetchServerSettingsL()

    {

    RBufWriteStream stream;

    // Set the request type.

    iType = EFetchSettings;

    // Package the request.

    stream.Open (*iRequestBuff);

    CleanupClosePushL (stream);

    stream.WriteInt32L ( iFolderListId);

    iRequestBuff->Compress ();

    CleanupStack::PopAndDestroy (/*stream*/);

    iRequestBuffPtr.Set ( iRequestBuff->Ptr(0).Ptr (), iRequestBuff->Size ());

    iSettingsResponseBuffer->ExpandL(0, KSettingsBufSize);

    iResponsePtr.Set((TUint8 *) iSettingsResponseBuffer->Ptr(0).Ptr(), KSettingsBufSize, 

            KSettingsBufSize);

    // Make the request.

    iObserver.SendAsyncCommand (EFeedsServerGetSettings, TIpcArgs (

            &iRequestBuffPtr, &iResponsePtr), iStatus);

    Start ();

    }

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

// CTransaction::FetchServerSettingsSyncL

//

// Handles the fetching of the feeds server settings synchronously.

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

//

void CTransaction::FetchServerSettingsSyncL()

    {

    TInt                  status(0);

    CBufFlat*             requestBuff = NULL;

    TPtr8                 requestBuffPtr(NULL, 0);

    CBufFlat*             responseBuff = NULL;

    TPtr8                 responsePtr(NULL, 0);

    RBufWriteStream       stream;

    requestBuff = CBufFlat::NewL(128);

    CleanupStack::PushL(requestBuff);

    // Package the request.

    stream.Open(*requestBuff);

    CleanupClosePushL(stream);

    stream.WriteInt32L( iFolderListId );    

    requestBuff->Compress();

    requestBuffPtr.Set( requestBuff->Ptr(0) );

    CleanupStack::PopAndDestroy(/*stream*/);

    responseBuff = CBufFlat::NewL(128);

    CleanupStack::PushL(responseBuff);

    // Make the request.

    responseBuff->ExpandL(0, KSettingsBufSize);

    responsePtr.Set((TUint8 *) responseBuff->Ptr(0).Ptr(), KSettingsBufSize, 

            KSettingsBufSize);

    status = iFeedInterface->SendReceiveSync(EFeedsServerGetSettings, TIpcArgs(&requestBuffPtr, &responsePtr));

    // Extract the settings if everything went ok.

    if (status == KErrNone)

        {

        iSetting = SettingsFromResponseBuffPtrL(*responseBuff);

        }

    CleanupStack::PopAndDestroy(responseBuff);

    CleanupStack::PopAndDestroy(requestBuff);

    }

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

// CTransaction::Settings

//

// return pointer to setting map,Caller takes ownership

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

//

EXPORT_C  TFeedsServerSetting CTransaction::Settings()

    {

    return iSetting; 

    }

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

// CTransaction::CancelAllL

//

// Request the FeedsServer to cancel all activities that can be cancelled.

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

//

void CTransaction::CancelAllL()

    {

    // Set the request type.

    iType = ECancelAll;

    // Make the request.

    iObserver.SendAsyncCommand (EFeedsServerCancelAll, TIpcArgs (), iStatus);

    Start ();

    }

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

// CTransaction::SettingsFromResponseBufferL

//

// Reads server response buffer and intialises iSetting;

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

//

void CTransaction::SettingsFromResponseBufferL()

    {

    RBufReadStream        stream;

    stream.Open(*iSettingsResponseBuffer, 0);

    CleanupClosePushL(stream);

    // Read the settings.  

    // NOTE: Be sure to adjust KSettingsBufSize if more settings are added.

    iSetting.iAutoUpdate = stream.ReadUint8L();

    iSetting.iAutoUpdateFreq = stream.ReadUint16L();

    iSetting.iAutoUpdateAP = stream.ReadUint32L();

    iSetting.iAutoUpdateWhileRoaming = stream.ReadUint8L();

    CleanupStack::PopAndDestroy(/*stream*/);

    }

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

// CTransaction::RequestCompletedL

//

// Called to handle the response.

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

//

void CTransaction::RequestCompletedL(TInt aStatusCode)

    {

    // Notify the observer if an error occurred.

    this->iTranStatus = aStatusCode;

    if ( aStatusCode != KErrNone)

        {

        iObserver.RequestHandlerCompleted (*this, aStatusCode);

        return;

        }

    switch (iType)

        {

        case EFetchSettings:

            {

            TRAPD(err,SettingsFromResponseBufferL());

            iObserver.RequestHandlerCompleted (*this, err);

            return;

            }

        case EFetchFeed:

            {

            if ( iServerResponseType != EFeedsServerConnectionNeeded &&iServerResponseType != EFeedsServerManualUpdateDone)

                {

                // Append the response chunk to the packed folder.

                if ( iServerResponseType == EFeedsServerTokensPayload)

                    {

                    iPacked->AppendTokenChunkL (iResponsePtr);

                    }

                else

                    {

                    iPacked->AppendStringTableChunkL (iResponsePtr);

                    }

                // If there is more data coming request the next chunk.

                if ( iServerResponseType != EFeedsServerPayloadDone)

                    {

                    // Reset the response.

                    iResponsePtr.Zero ();

                    // Clear the request buffer too.

                    iRequestBuffPtr.Set (NULL, 0);

                    // Get the next chunk asynchronously.

                    iObserver.SendAsyncCommand (EFeedsServerGetFeed, TIpcArgs (

                    		&iRequestBuffPtr, &iServerResponseTypePkg,

                    		&iResponsePtr), iStatus);

                    Start ();

                    }

                // Otherwise process the completed folder.

                else

                    {

                    // Create the new folder and notify the observer.

                    iFeedsEntity = CFeedsEntity::NewL ((CPackedFeed*)iPacked,iFeedInterface);

                    delete iPacked;

                    iPacked = NULL;

                    iObserver.RequestHandlerCompleted (*this, KErrNone);

                    }

                }

            else

                if ( iServerResponseType == EFeedsServerConnectionNeeded)

                    {

                    // Ask client for connection

                    TInt connectionPtr;

                    TInt sockSvrHandle;

                    TBool newConn;

                    TApBearerType bearerType;

                    TRAPD( err, iObserver.NetworkConnectionNeededL( &connectionPtr, sockSvrHandle, newConn, bearerType ) );

                    if ( err == KErrNone)

                        {

                        // Prepare RConnection name

                        RConnection* connPtr=  REINTERPRET_CAST( RConnection*, connectionPtr );

                        TName name;

                        connPtr->Name ( name);

                        // Package the request.

                        RBufWriteStream stream;

                        //

                        stream.Open (*iRequestBuff);

                        CleanupClosePushL (stream);

                        //