/*

* Copyright (c) 2007 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:  This is the client side interface for the conversation

*               server.

*

*/

// INCLUDE FILES

// SYSTEM INCLUDES

#include <ccsconversationentry.h>

#include <ccsclientconversation.h>

#include <mcsresultsobserver.h>

#include <mcsconversationlistchangeobserver.h>

#include <mcsconversationchangeobserver.h>

#include <mcscachingstatusobserver.h>

#include <ccsrequesthandler.h>

#include <rcssession.h>

#include <ccsnotificationhandler.h>

//USER INCLUDES

#include "ccsdebug.h"

#include "ccsconversationchangeobserver.h"

const TInt  KSmallIpcBuffer = 256; //256 bytes

const TInt KBigIpcBuffer = 2048; // 2K

// ========================= MEMBER FUNCTIONS ==================================

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

// CCSRequestHandler::NewL()

// Two-phased constructor.

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

EXPORT_C CCSRequestHandler* CCSRequestHandler::NewL()

    {

    PRINT ( _L("Enter CCSRequestHandler::NewL") );

    CCSRequestHandler* self = NewLC( );

    CleanupStack::Pop( self );

    PRINT ( _L("End CCSRequestHandler::NewL") );

    return( self ) ;

    }

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

// CCSRequestHandler::NewLC()

// Two-phased constructor.

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

EXPORT_C CCSRequestHandler* CCSRequestHandler::NewLC(/*CVPbkContactManager* aVPbkContactManager*/)

    {

    PRINT ( _L("Enter CCSRequestHandler::NewLC") );

    CCSRequestHandler* self = new ( ELeave ) CCSRequestHandler();

    CleanupStack::PushL( self );

    self->ConstructL(/*aVPbkContactManager*/);

    PRINT ( _L("End CCSRequestHandler::NewLC") );

    return self;

    }

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

// CCSRequestHandler::CCSAsyncRequestHandler()

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

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

CCSRequestHandler::CCSRequestHandler()

: CActive( EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CCSRequestHandler::ConstructL()

// Symbian 2nd phase constructor can leave.

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

void CCSRequestHandler::ConstructL()

    {

    PRINT ( _L("Enter CCSRequestHandler::ConstructL") );

    User::LeaveIfError( iSession.Connect() );

    // Notification handler

    iNotificationHandler = CCsNotificationHandler::NewL(this);

    // Observers

    iResultsObserver = NULL;

    iCachingStatusObserver = NULL;

    iConversationListChangeObserver = NULL;

    iConversationChangeObserver = NULL;

    PRINT ( _L("End CCSRequestHandler::ConstructL") );

    }

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

// CCSRequestHandler::~CCSRequestHandler()

// Destructor.

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

CCSRequestHandler::~CCSRequestHandler()

    {

    PRINT ( _L("Enter CCSRequestHandler::~CCSRequestHandler") );

    Cancel(); 

    // Cleanup

    if ( iBuffer )

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    if ( iResultsBuffer )

        {

        delete iResultsBuffer;

        iResultsBuffer = NULL;

        }

    if ( iNotificationHandler )

        {

        delete iNotificationHandler;

        iNotificationHandler = NULL;

        }

    if( iListResultsBuffer )

        {

        delete iListResultsBuffer;

        iListResultsBuffer=NULL;

        }

    if( iConvResultsBuffer )

        {

        delete iConvResultsBuffer;

        iConvResultsBuffer=NULL;

        }

    // Close the session

    iSession.Close();

    PRINT ( _L("End CCSRequestHandler::~CCSRequestHandler") );

    }

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

// CCSRequestHandler::HandleGetConversationListResults()

// This shall handle all entry list result from server

//

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

void CCSRequestHandler::HandleGetConversationListResults()

    {

    PRINT( _L("Enter CCSRequestHandler::HandleGetConversationListResults") );

    TInt error = KErrNone;

    RPointerArray<CCsClientConversation> clientConversationList;

    // Parse the results

    RDesReadStream resultStream(iListResultsBuffer->Des());

    TInt listCount = 0;

    TRAP(error, 

            resultStream.PushL();

            listCount = resultStream.ReadUint16L();

            resultStream.Pop()

            );

    if(error != KErrNone)

        {

        //call panic

        }

    for (TInt iloop = 0 ; iloop < listCount; iloop++)

        {

        TRAP(error,

                resultStream.PushL();

                CCsClientConversation* clientConversation = CCsClientConversation::NewL();

                CleanupStack::PushL(clientConversation);

                clientConversation->InternalizeL(resultStream);

                clientConversationList.AppendL(clientConversation);

                CleanupStack::Pop(clientConversation);

                resultStream.Pop()

                );

        if(error != KErrNone)

            {

            //call panic

            }

        }

    // Clear all the internal buffers

    // Cleanup

    delete iListResultsBuffer;

    iListResultsBuffer = NULL;

    resultStream.Close();

    // Pass the results to the observer    

    if ( iResultsObserver )

        {

        iResultsObserver->ConversationList(clientConversationList);

        }

    clientConversationList.ResetAndDestroy();

    PRINT( _L("End CCSRequestHandler::HandleGetConversationListResults") );

    }

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

// CCSRequestHandler::HandleGetConversationResults()

// This shall handle GetCoversation results async from server

//

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

void CCSRequestHandler::HandleGetConversationResults()

    {

    PRINT( _L("Enter CCSRequestHandler::HandleGetConversationResults") );

    TInt error = KErrNone;

    RPointerArray<CCsConversationEntry> ConversationEntryList;

    // Parse the results

    RDesReadStream resultStream(iConvResultsBuffer->Des());

    TInt  conversationEntryCount = 0;

    TRAP(error, resultStream.PushL();

    conversationEntryCount = resultStream.ReadInt32L();

    resultStream.Pop());

    if(error != KErrNone)

        {

        //call panic

        }

    PRINT1 ( _L("Number of conversation entries = %d"), conversationEntryCount );

    // conversation entries

    for ( TInt iloop = 0; iloop < conversationEntryCount; iloop++ )

        {

        TRAP(error,

                resultStream.PushL();

        CCsConversationEntry* conversationEntry = CCsConversationEntry::NewL();

        CleanupStack::PushL(conversationEntry);

        conversationEntry->InternalizeL(resultStream);

        ConversationEntryList.AppendL(conversationEntry);

        CleanupStack::Pop(conversationEntry);

        resultStream.Pop());

        if(error != KErrNone)

            {

            //call panic

            }

        }

    // Cleanup

    if ( iBuffer )

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    delete iConvResultsBuffer;

    iConvResultsBuffer = NULL;

    resultStream.Close();

    // Pass the results to the observer

    if ( iResultsObserver )

        {

        iResultsObserver->Conversations(ConversationEntryList);

        }

    // cleanup heap data

    ConversationEntryList.ResetAndDestroy();

    PRINT_TIMESTAMP ("End CCSRequestHandler::HandleGetConversationResults");

    }

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

// CCSRequestHandler::HandleGetEntryListOverflow()

// Handle the buffer overflow error for get entry list results

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

void CCSRequestHandler::HandleGetConversationListOverflow()

    {

    PRINT ( _L("Enter CCSRequestHandler::HandleGetConversationListOverflow") );

	if ( !iListResultsBuffer )

        {

		return;

		}

    TInt error = KErrNone;

    // New buffer size is now stored in results buffer

    RDesReadStream stream(iListResultsBuffer->Des());

    TInt bufferSize = 0;

    TRAP(error, 

            stream.PushL();

            bufferSize = stream.ReadInt32L();

            stream.Pop()

            );

    if(error != KErrNone)

        {

        //call panic

        }

    stream.Close();

    // Delete and recreate the results buffer

    delete iListResultsBuffer;

    iListResultsBuffer = NULL;

    // Buffer created for the new size

    TRAP(error, 

            iListResultsBuffer = HBufC8::NewL(bufferSize);

            iSession.GetConversationListL(iListResultsBuffer->Des(),iStatus)

            );

    if(error != KErrNone)

        {

        //call panic

        }

    SetActive();

    PRINT ( _L("End CCSRequestHandler::HandleGetEntryListOverflow") );

    }

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

// CCSRequestHandler::HandleGetConversationOverflow()

// Handle the buffer overflow error for get conversation results

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

void CCSRequestHandler::HandleGetConversationOverflow()

    {

    PRINT ( _L("Enter CCSRequestHandler::HandleGetConversationOverflow") );

	   if ( !iConvResultsBuffer )

        {

				return;

				}

    TInt error = KErrNone;

    // New buffer size is now stored in results buffer

    RDesReadStream stream(iConvResultsBuffer->Des());

    TInt bufferSize = 0;

    // Read the buffer size and create a new buffer

    TRAP(error, 

            stream.PushL();

            bufferSize = stream.ReadInt32L();

            stream.Pop()

            );

    if(error != KErrNone)

        {

        //call panic

        }

    stream.Close();

    // Delete and recreate the results buffer

    delete iConvResultsBuffer;

    iConvResultsBuffer = NULL;

    // Buffer created for the new size

    TRAP(error, 

            iConvResultsBuffer = HBufC8::NewL(bufferSize);

            iSession.SendNewBufferGetConversationL(iConvResultsBuffer->Des(),iStatus)

            );

    if(error != KErrNone)

        {

        //call panic

        }

    SetActive();

    PRINT ( _L("End CCSRequestHandler::HandleGetConversationListOverflow") );

    }

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

// CCSRequestHandler::RequestResultsEventL()

// Add conversation result Observer

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

EXPORT_C void CCSRequestHandler::RequestResultsEventL(

        MCsResultsObserver* aObserver)

    {

    iResultsObserver = aObserver;

    }

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

// CCSRequestHandler::RemoveResultsEventL()

// Remove conversation result observer

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

EXPORT_C void CCSRequestHandler::RemoveResultsEventL

(MCsResultsObserver* /*aObserver*/)

    {

    iResultsObserver = NULL;

    }

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

// CCSRequestHandler::RequestConversationListChangeEventL()

// Add conversation list change event Observer

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

EXPORT_C void CCSRequestHandler::RequestConversationListChangeEventL(

        MCsConversationListChangeObserver* aObserver)

    {

    iConversationListChangeObserver = aObserver;

    // Register to server.

    iNotificationHandler->RequestConversationListChangeEventL();  

    }

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

// CCSRequestHandler::RemoveConversationListChangeEventL()

// Remove conversation list change event Observer

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

EXPORT_C void CCSRequestHandler::RemoveConversationListChangeEventL(

        MCsConversationListChangeObserver* /*aObserver*/)

    {

    iConversationListChangeObserver = NULL;

    // De-register from the server           

    iNotificationHandler->RemoveConversationListChangeEventL();   

    }

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

// CCSRequestHandler::RequestConversationChangeEventL()

// Add conversation change event Observer

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

EXPORT_C void CCSRequestHandler::RequestConversationChangeEventL(

        MCsConversationChangeObserver* aObserver,

        CCsClientConversation* aClientConversation)

    {

    CCsConversationChangeObserver* conChgObserver = 

            CCsConversationChangeObserver::NewL();

    CleanupStack::PushL(conChgObserver);

    conChgObserver->SetClientConversationL(*aClientConversation);

    conChgObserver->SetConversationChangeObserverL(aObserver);

    iConversationChangeObserver = conChgObserver;

    CleanupStack::Pop(conChgObserver);

    iNotificationHandler->RequestConversationChangeEventL(aClientConversation);

    }

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

// CCSRequestHandler::RemoveConversationChangeEventL()

// Remove conversation change event observer

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

EXPORT_C void CCSRequestHandler::RemoveConversationChangeEventL(

        MCsConversationChangeObserver* /*aObserver*/,

        CCsClientConversation* aClientConversation)

    {

    if ( iConversationChangeObserver )

        {

        delete iConversationChangeObserver;

        iConversationChangeObserver = NULL;

        }

    iNotificationHandler->RemoveConversationChangeEventL(aClientConversation);

    }

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

// CCSRequestHandler::RequestCachingStatusEventL()

// Add caching status Observer

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

EXPORT_C void CCSRequestHandler::RequestCachingStatusEventL(

        MCsCachingStatusObserver* /*aObserver*/)

    {

    User::Leave(KErrNotSupported);

    }

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

// CCSRequestHandler::RemoveCachingStatusEventL()

// Remove caching status Observer

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

EXPORT_C void CCSRequestHandler::RemoveCachingStatusEventL(

        MCsCachingStatusObserver* /*aObserver*/)

    {

    User::Leave(KErrNotSupported);

    }

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

// CCSRequestHandler::RunL()

// Invoked to handle responses from the server.

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

void CCSRequestHandler::RunL()

    { 

    switch ( iStatus.Int() )

        {

        case EGetConversationListOperationComplete:

            HandleGetConversationListResults();

            break;

        case EGetConversationListBufferOverflow:

            HandleGetConversationListOverflow();

            break;

        case EGetConversationOperationComplete:

            HandleGetConversationResults();

            break;

        case EGetConversationBufferOverflow:

            HandleGetConversationOverflow();

            break;

        default:

            HandleErrorL(iStatus.Int());

            break;

        }

    }

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

// CCSRequestHandler::HandleErrorL()

// Send the error code to the client.

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

void CCSRequestHandler::HandleErrorL(TInt /*aErrorCode*/)