/*

* 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 "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:  cache message change observer

*

*/

//  INCLUDE FILES

#include "cimcacheeventhandler.h"

#include "mimcacheclient.h"

#include "mimcacheeventhandler.h"

// logs

#include "imcachedebugtrace.h"

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

// CIMCacheEventHandler::NewL

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

//

CIMCacheEventHandler* CIMCacheEventHandler::NewL( 

								MIMCacheClient& aRegistrar, 

								MIMCacheEventHandler& aHandler)

    {

    TRACE( T_LIT("CIMCacheEventHandler::NewL() begin") );

	CIMCacheEventHandler* self = new ( ELeave ) CIMCacheEventHandler( aRegistrar ,aHandler ) ;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );  //self

	TRACE( T_LIT("CIMCacheEventHandler::NewL() end") );

    return self;

    }

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

// CIMCacheEventHandler::ConstructL

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

//

void CIMCacheEventHandler::ConstructL()

    {

    TRACE( T_LIT("CIMCacheEventHandler::ConstructL() begin") );

    iContinueObserving = ETrue ;

   	CActiveScheduler::Add( this );

	iRegistrar.RegisterObserverToServerL( iStatus ,EIMCacheObserveMessageUpdateRegister );

	SetActive();

	TRACE( T_LIT("CIMCacheEventHandler::ConstructL() end") );

    }

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

// CIMCacheEventHandler::~CIMCacheEventHandler

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

//

CIMCacheEventHandler::~CIMCacheEventHandler()

	{

	TRACE( T_LIT("CIMCacheEventHandler::~CIMCacheEventHandler() begin") );

	Cancel();

	TRACE( T_LIT("CIMCacheEventHandler::~CIMCacheEventHandler() end") );

	}

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

// CIMCacheEventHandler::CIMCacheEventHandler(

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

//

CIMCacheEventHandler::CIMCacheEventHandler(

								 MIMCacheClient& aRegistrar , 

								 MIMCacheEventHandler& aHandler ) :

	CActive( CActive::EPriorityIdle ),

  	iRegistrar( aRegistrar ),

  	iUpdateHandler( aHandler )

 	{

 	TRACE( T_LIT("CIMCacheEventHandler::CIMCacheEventHandler()") );

	}

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

// CIMCacheEventHandler::RunL

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

//

void CIMCacheEventHandler::RunL()

	{

	TRACE( T_LIT("CIMCacheEventHandler::RunL() begin") );

	TRACE( T_LIT("CIMCacheEventHandler::RunL() iStatus code = "),iStatus.Int()  );

	switch( iStatus.Int() )

		{

		case EIMOperationUnreadMessage :

		case EIMOperationDataAvailable :

		case EIMOperationMessageAdded :

			{

			// message data available get the data	

            GetBufferChatDataL();

			break;	

			}

	   case EIMOperationCompleted :

	   		{

	   		iUpdateHandler.HandleIMCacheEventL( EIMCacheRequestCompleted, NULL );	

	   		}

	    case EIMOperationChatStarted :

		    {

		    iUpdateHandler.HandleIMCacheEventL( EIMCacheRequestCompleted, NULL );

		    break;	

		    }

		case EIMOperationUnreadChange:

			{

			iUpdateHandler.HandleIMCacheEventL( EIMCacheRequestCompleted, NULL );

			break;	

			}

		case EIMOperationChatAdded :

			{

			// chat information

		    GetBufferedChatItemL(EIMCacheNewChat);

			break;	

			}

		case EIMOperationChatDeleted :

			{

			// message data available get the data	

            GetBufferedChatItemL(EIMCacheChatClosed );		

			break;	

			}

		 case EIMOperationAllChatDeleted:

		     {

		     iUpdateHandler.HandleIMCacheEventL( EIMCacheAllChatClosed, NULL );

		     break;

		     }

		case EIMOperationUnRegistered:

			{

			TRACE( T_LIT("CIMCacheEventHandler::RunL() EIMOperationUnRegistered") );

			iContinueObserving = EFalse;	

			break;	

			}

		default :

		    {

		    TRACE( T_LIT("CIMCacheEventHandler::RunL() default") );

		    break;	

		    }

		}	

	// Comment: cancel operation is changes as synchronous. iContinueObserving from event

	// can not really be trusted since complete code might be different if leave has occured 

	// for example. Cancel is handled here as generic cancel.

	TRACE( T_LIT("CIMCacheEventHandler::RunL() iContinueObserving iContinueObserving = %d") ,iContinueObserving);

	// check need to continue observing to server

	if( iContinueObserving && KErrCancel != iStatus.Int() )

		{

		iRegistrar.RegisterObserverToServerL( iStatus ,EIMCacheObserveMessageUpdateRegister );

		SetActive();

		}

	TRACE( T_LIT("CIMCacheEventHandler::RunL() end") );

	}

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

// CIMCacheEventHandler::DoCancel

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

//	

void CIMCacheEventHandler::DoCancel()

	{

	TRACE( T_LIT("CIMCacheEventHandler::DoCancel() ") );

	// Comment: set to EFalse here since we can not trust other changes. See

	// comments in RunL

	iContinueObserving = EFalse;

	if( IsActive() )

        {

        TRAP_IGNORE(iRegistrar.CancelRequestL( iStatus ,EIMCacheCancelRequest ));

        }

	}

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

// CIMCacheEventHandler::RunError()

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

//

TInt CIMCacheEventHandler::RunError( TInt /* aError */)

    {

    TRACE( T_LIT("CVIMPSTEngineCVListener::RunError() start"));

    return KErrNone;

    }

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

// CIMCacheEventHandler::UnRegisterObserver

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

//		

void CIMCacheEventHandler::UnRegisterObserver()

	{

	TRACE( T_LIT("CIMCacheEventHandler::UnRegisterObserver() begin") );

	if( IsActive() )

		{

		TRACE( T_LIT("CIMCacheEventHandler::UnRegisterObserver() active") );

		TRAP_IGNORE(iRegistrar.UnRegisterObserverToServerL( iStatus ,EIMCacheObserveMessageUpdateUnRegister ));

		}

	TRACE( T_LIT("CIMCacheEventHandler::UnRegisterObserver() end") );	

	}

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

// CIMCacheEventHandler::GetBufferChatDataL

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

//

void CIMCacheEventHandler::GetBufferChatDataL( ) 

    {

    TRACE( T_LIT("CIMCacheEventHandler::GetBufferChatDataL() begin") );

	TBool more = ETrue;

    while(more)

        {

        TPtr8 bufferPtr = iRegistrar.GetBufferedDataL( EIMCacheGetBufferedPackets );

        InternalizeChatDataL( bufferPtr , more );

        }

    TRACE( T_LIT("CIMCacheEventHandler::GetBufferChatDataL() end") );

    }

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

// CIMCacheEventHandler::InternalizeChatDataL

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

void CIMCacheEventHandler::InternalizeChatDataL( TPtr8 aChatDataBuffer , TBool& aMore )

    {

    TRACE( T_LIT("CIMCacheEventHandler::InternalizeChatDataL() Start") );

    if( 0 == aChatDataBuffer.Length())

        {

        TRACE( T_LIT("CIMCacheEventHandler::InternalizeChatDataL()  aChatDataBuffer is zeor, hence returning ") );

        return;

        }

   	RDesReadStream readAllStream ;

	RDesReadStream readStream ;    

	readAllStream.Open( aChatDataBuffer );

	CleanupClosePushL(readAllStream);

	TInt messageCount = readAllStream.ReadInt16L();

	for( TInt i=0; i< messageCount; i++)

		{

		SIMCacheMessageData chatData =

		    {

		    TIMCacheMessageType(0),

		    };

		TInt size = readAllStream.ReadInt16L() ;

		HBufC8* mBuffer  = HBufC8::NewLC( size );

		TPtr8 mBufferPtr = mBuffer->Des();

		readAllStream.ReadL( mBufferPtr , size );

		readStream.Open( *mBuffer );        

		CleanupClosePushL(readStream) ;

		chatData.iMessageType   = static_cast<TIMCacheMessageType>( readStream.ReadInt16L() );

		chatData.iMessagerType  = static_cast<TIMCacheMessagerType>( readStream.ReadInt16L() );

		chatData.iContentType   = static_cast<TIMCacheContentType>( readStream.ReadInt16L() );

		chatData.iTime          = static_cast<TReal64>( readStream.ReadReal64L() );

		TInt buddyLength = readStream.ReadInt16L();

		HBufC* buddy     = HBufC::NewLC( buddyLength );

		TPtr buddyPtr    = buddy->Des();

		readStream.ReadL( buddyPtr , buddyLength );

		chatData.iBuddyId = buddy;

		TInt textSize = readStream.ReadInt16L();

		HBufC* text  = HBufC::NewLC( textSize );

		TPtr textPtr = text->Des(); 

		readStream.ReadL( textPtr , textSize);            

		chatData.iText = text;

		iUpdateHandler.HandleIMCacheEventL(EIMCacheNewMessage , &chatData);

		CleanupStack::PopAndDestroy(4);//close read stream, delete mBuffer, text, buddy 

		}

	aMore = static_cast<TBool>( readAllStream.ReadInt16L() );

	CleanupStack::PopAndDestroy();//readAllStream.    

    TRACE( T_LIT("CIMCacheEventHandler::InternalizeChatDataL() End") );

    }

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

// CIMCacheEventHandler::GetBufferedChatItemL

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

//

void CIMCacheEventHandler::GetBufferedChatItemL( TIMCacheEventType aEventType )

    {

    TRACE( T_LIT("CIMCacheAccessEventHandler::GetBufferedChatItemL() begin") );

    TPtr8 bufferPtr = iRegistrar.GetBufferedDataL( EIMCacheGetBufferedPackets );

    InternalizeChatItemL( aEventType, bufferPtr );

    TRACE( T_LIT("CIMCacheAccessEventHandler::GetBufferedChatItemL() end") );

    }

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

// CIMCacheEventHandler::InternalizeChatItemL

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

//

void CIMCacheEventHandler::InternalizeChatItemL( TIMCacheEventType aEventType, 

                                                 TPtr8 aContactBuffer )

    {

    TRACE( T_LIT("CIMCacheClient::InternalizeChatItemL() begin") );   

    if( 0 == aContactBuffer.Length())

          {

          TRACE( T_LIT("CIMCacheEventHandler::InternalizeChatDataL()  aChatDataBuffer is zeor, hence returning ") );

          return;

          }

    RDesReadStream readAllStream ;

    RDesReadStream readStream ;    

    readAllStream.Open( aContactBuffer );

    CleanupClosePushL(readAllStream);

    TInt messageCount = readAllStream.ReadInt16L();

    for( TInt i=0; i< messageCount; i++)

        {

        SIMCacheChatItem chatItem =

          {

          0,

          };

        TInt size = readAllStream.ReadInt16L() ;

        HBufC8* mBuffer  = HBufC8::NewLC( size );

        TPtr8 mBufferPtr = mBuffer->Des();

        readAllStream.ReadL( mBufferPtr , size );

        readStream.Open( *mBuffer );        

        CleanupClosePushL(readStream) ;

        chatItem.iServiceId  = static_cast<TInt>( readStream.ReadInt16L() );

        TInt textSize = readStream.ReadInt16L();

        HBufC* buddyId = HBufC::NewLC( textSize );

        TPtr buddyIdPtr = buddyId->Des(); 

        readStream.ReadL( buddyIdPtr , textSize);

        chatItem.iBuddyId = buddyId;

        iUpdateHandler.HandleIMCacheEventL( aEventType , &chatItem );

        CleanupStack::PopAndDestroy(3);//buddyId , close read stream, delete mBuffer.      

        }

    CleanupStack::PopAndDestroy();//readAllStream.    

    TRACE( T_LIT("CIMCacheClient::InternalizeChatItemL() End") );

    }

//  end of file