/*
* 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: 
* handler class for imps common client.
*
*/


// INCLUDE FILES
#include <e32std.h>

#include "impsclient.h"
#include "impsfields.h"
#include "impspacked.h"
#include "impskey.h"
#include "impshandler.h"
#include "impsutils.h"
#include "impsservercommon.h"
#include "impserrors.h"
#include "impsdetailed.h"
#include "impsdataaccessor.h"
#include "impscdatautils.h"

// MACROS
#ifndef _DEBUG
#define _NO_IMPS_LOGGING_
#endif

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

// -----------------------------------------------------------------------------
// TWvBuf::TWvBuf
// -----------------------------------------------------------------------------

TWvBuf::TWvBuf( HBufC8* aBuf ) :
        iPtr( aBuf->Des() ) 
        {}

// ----------------------------------------------------------------------------
// CImpsHandler2::CImpsHandler2()
// ----------------------------------------------------------------------------
CImpsHandler2::CImpsHandler2( 
    TInt aPriority, 
    RImpsClient2& aClient  ) :
    CActive( aPriority ), 
    iClient( aClient ),
    iBody( NULL ),
    iPtrStore( NULL )
    {
    CActiveScheduler::Add( this );
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::~CImpsHandler2()
// ----------------------------------------------------------------------------
 CImpsHandler2::~CImpsHandler2()
     {

     delete iBody;
     delete iFields;
     delete iPtrStore;
     delete iBusyTimer;

     if ( iDestroyedPtr )
         {
         // We are called via own RunL!
         *iDestroyedPtr = ETrue;
         iDestroyedPtr = NULL;
         }

     // Do not call Cancel() here, because of it is called outside if needed.
     // This is observer for server thread, so do not cancel yourself!
     }

// ----------------------------------------------------------------------------
// CImpsHandler2::StartRun()
// ----------------------------------------------------------------------------
void CImpsHandler2::StartRun()
    {

    // Start to wait push messages from the server
    iStatus = KRequestPending;
    SetActive();
    iFields->Reset();

    }

// ----------------------------------------------------------------------------
// CImpsHandler2::RunL()
// ----------------------------------------------------------------------------
void CImpsHandler2::RunL()
    {
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("CImpsHandler2::RunL begin status=%d h=%d cli=%d"), 
        iStatus.Int(), (TInt)this, (TInt)&iClient );
#endif

    // Set the member to point to stack variable
    TBool   destroyed( EFalse );
    iDestroyedPtr = &destroyed;
    // Is the event handled
    TBool handled( EFalse );
    TInt err = KErrNone;
    
    
    // Server is busy
    if ( iStatus == KErrServerBusy )
        {
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("CImpsHandler2::Starting timer") ); 
#endif
		iBusyTimer->Start();
        return;
        }
    
    // Server is cancelled
    if ( iStatus == KErrCancel || iStatus == KErrServerTerminated )
        {
        return;
        }

    // special "error" codes for status changes
    if ( iStatus == KImpsOnlineStatus ||
         iStatus == KImpsOfflineStatus ||
         iStatus == KImpsNotLoggedStatus || 
         iStatus == KImpsErrorShuttingDown )
        {
        TImpsServiceStatus newStatus = EImps_ON_LINE;
        if ( iStatus == KImpsNotLoggedStatus )
            {
            newStatus = EImps_NOT_LOGGED;
            }
        else if ( iStatus == KImpsErrorShuttingDown )
            {
            newStatus = EImps_SHUTTING_DOWN;
            }
        if ( iStatusHandler )
            {
            TInt err ( KErrNone );
            TRAP( err, iStatusHandler->HandleStatusChangeL( newStatus , *iClient.CspIdentifier() ));
            handled = ETrue;
            }
        }

    // Destructor sets this to ETrue. An application may have called unregister
    if ( destroyed )
        {       
        return;
        }
    
    TInt dataLength = iStatus.Int();

    // Check first if a special OOM error event
    if ( dataLength > 0 && ( dataLength & KImpsOOMReply ) )
        {
        TInt errId = dataLength & KImpsOOMReplyOpId;
        dataLength = 0;
        err = KErrNoMemory;
        // This cannot leave with NULL fields parameter
        HandleErrorEventL( errId, KErrNoMemory, NULL );
        }

    // Read the data if any to iFields
    // Check if need to read message body separately
    TBool comp( ETrue );
    if ( dataLength > 0 )
        {
        TRAP( err, comp = ReadDataL( dataLength ) );
        }

    if ( !err && !handled && comp )
        {
        // Not here if reading of data fails
        CImpsFields* errF = ( dataLength > 0 ? iFields : NULL );
        { // These parenthises must be here.
          // Otherwise the program will crash
          // This is releated to the destroying this object
          // and trap frame.

        // this trap handles all internal errors
        // errors caused by callbacks are trapped elsewhere
        TRAP( err, HandleEventL( errF ) ); 
        if ( err != KErrNone )
            {
            SImpsEventData* event = (SImpsEventData*)iEventData.Ptr();
            HandleErrorEventL( event->iOpCode, err, NULL );
            }
        }
        }

    // Destructor sets this to ETrue, nice trick.
    if ( !destroyed )
        {       
        // Activate again and reset data.
        // This must not leave but has to ask for more by
        // calling either EventHandled() or EventBody(). 
        StartRun();
        TInt bufSize = CurrentSize();
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("CImpsHandler2: comp=%d bufSize=%d h=%d cli=%d"), 
        comp, bufSize, (TInt)this, (TInt)&iClient );
#endif
        if ( comp )
            {
            // Message handling is complete. Free the buffer if the 
            // message was a big one.
            if ( bufSize > KImpsIPCThreshold )
                {
                ResetBuffers();
                }
            EventHandled();
            }
        else
            {
            if ( CurrentSize() < dataLength )
                {
                // allocate memory if needed
                ResetBuffers();
                TRAP( err, 
                    {
                    iBody = HBufC8::NewL( dataLength );  
                    iPtrStore = new (ELeave) TWvBuf( iBody );
                    } );
                }
            if ( err )
                {
                ResetBuffers();
                EventHandled();
                }
            else
                {
                // Ask rest of the message
                EventBody();
                }
            }
        }
    else
        {
#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log(_L("CImpsHandler2: DESTROYED **** cli=%d"), (TInt)&iClient );
#endif
        }

    iDestroyedPtr = NULL; 

#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("CImpsHandler2: RunL ends cli=%d"), (TInt)&iClient);
#endif    
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::ReadDataL()
// ----------------------------------------------------------------------------
TBool CImpsHandler2::ReadDataL( TInt aLength )
    {
    // Event data has been given in next event request
    SImpsEventData* event = (SImpsEventData*)iEventData.Ptr();

    if ( event->iMessageBody )
        {
        // verify iBody.Length and aLength
       __ASSERT_DEBUG( iBody && aLength > 0 && iBody->Des().Length() == aLength, 
                       User::Panic( KImpsPanicCategory, EImpsCorrupted ) );

        // Unpack the streaming
        iFields->Reset();
        TImpsPackedEntity packed( iBody );
        packed.UnpackEntityL( *iFields );
        }
    else if ( aLength > CurrentSize() )
        {
        // This means event without body
        return EFalse;
        }

    return ETrue;
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::DoCancel()
// ----------------------------------------------------------------------------
void CImpsHandler2::DoCancel()
    {

    // Complete the request with error
    TRequestStatus* s = &iStatus;
    User::RequestComplete( s, KErrCancel );
    }

// ----------------------------------------------------------------------------
// CImpsHandler2:: SetStatusHandlerL
// ----------------------------------------------------------------------------
void CImpsHandler2::SetStatusHandlerL( MImpsStatusHandler2* aObs)
    {

    iStatusHandler = aObs;
    // register new handler
    if ( iStatusHandler )
        {
        DoRegisterStatusHandlerL(  );
        }
    else
        {
        DoUnregisterStatusHandlerL( );
        }
    }

// ----------------------------------------------------------------------------
// CImpsHandler2:: SetErrorHandlerL
// ----------------------------------------------------------------------------
void CImpsHandler2::SetErrorHandlerL( MImpsErrorHandler2* aObs)
    {

    iErrorHandler = aObs;
    // register new handler
    if ( iErrorHandler )
        {
        DoRegisterErrorHandlerL(  );
        }
    else
        {
        DoUnregisterErrorHandlerL( );
        }
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::DoRegisterStatusHandlerL
// ----------------------------------------------------------------------------
void CImpsHandler2::DoRegisterStatusHandlerL(  )
    {
    TInt ret =  iClient.SendReceive( EImpsServStatusReg, TIpcArgs() );
    User::LeaveIfError( ret );
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::DoUnregisterStatusHandlerL
// ----------------------------------------------------------------------------
void CImpsHandler2::DoUnregisterStatusHandlerL(  )
    {
    TInt ret =  iClient.SendReceive( EImpsServStatusUnreg, TIpcArgs() );
    User::LeaveIfError( ret );
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::DoRegisterErrorHandlerL
// ----------------------------------------------------------------------------
void CImpsHandler2::DoRegisterErrorHandlerL(  )
    {
    TInt ret =  iClient.SendReceive( EImpsServDetailedReg, TIpcArgs() );
    User::LeaveIfError( ret );
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::DoUnregisterErrorHandlerL
// ----------------------------------------------------------------------------
void CImpsHandler2::DoUnregisterErrorHandlerL(  )
    {
    TInt ret =  iClient.SendReceive( EImpsServDetailedUnreg, TIpcArgs() );
    User::LeaveIfError( ret );
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::HandleErrorEventL
// ----------------------------------------------------------------------------
void CImpsHandler2::HandleErrorEventL(
            TInt aOpCode, TInt aStatus, CImpsFields* aFields)
    {

#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("CImpsHandler2: HandleErrorEventL opid=%d stat=%d cli=%d"),
                aOpCode, aStatus, (TInt)&iClient );
#endif


    if ( !iErrorHandler )
        {
        // handler should exist
        return;
        }

    if ( aFields == NULL )
        {
#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log(_L("CImpsHandler2: HandleError call"));
#endif
        // This has been internal error
        iErrorHandler->HandleErrorL( 
            aStatus,
            aOpCode,
            NULL,
            NULL,
            *iClient.CspIdentifier() );
        return;
        }


    CImpsDetailed* myDet = new (ELeave) CImpsDetailed(4);
    CleanupStack::PushL( myDet );       // <<< myDet
    TPtrC descr;
    descr.Set( KNullDesC );

    CImpsKey* myKey = CImpsKey::NewLC();    // <<< myKey
    CImpsDataAccessor* myAc = CImpsDataAccessor::NewL( aFields );
    CleanupStack::PushL( myAc );            // <<< myAc

    TImpsCDataUtils::GetDetailedResultL( myKey, myAc, descr, myDet );
    CleanupStack::PopAndDestroy(2);     // >>> myKey, myAc

#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("CImpsHandler2: HandleError call"),
                aOpCode, aStatus );
#endif

    iErrorHandler->HandleErrorL( 
        aStatus,
        aOpCode,
        &descr,
        myDet,
        *iClient.CspIdentifier() );

    CleanupStack::PopAndDestroy(1);  // >>> myDet
    }

// -----------------------------------------------------------------------------
// CImpsHandler2::ConstructL
// -----------------------------------------------------------------------------
void CImpsHandler2::ConstructL()
    {
    iFields = CImpsFields::NewL();
    iBusyTimer = new (ELeave) CImpsHandlerTimer( CActive::EPriorityStandard, *this);
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::EventHandled()
// ----------------------------------------------------------------------------
void CImpsHandler2::EventHandled()
    {
    TInt bufSize = CurrentSize();
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("CImpsHandler2: EImpsServNextEvent bufSize=%d h=%d cli=%d"), 
        bufSize, (TInt)this, (TInt)&iClient );
#endif
    iArgs.Set( 0, &iEventData );
    iArgs.Set( 1, &iPtrStore->iPtr ); 
    iArgs.Set( 2, bufSize );      
    iClient.SendReceive( EImpsServNextEvent, iArgs, iStatus );
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::EventBody()
// ----------------------------------------------------------------------------
void CImpsHandler2::EventBody()
    {
    __ASSERT_DEBUG( iBody && iPtrStore, 
                    User::Panic( KImpsPanicCategory, EImpsCorrupted ) );
    TInt bufSize = CurrentSize(); 
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("CImpsHandler2: EImpsServEventBody bufSize=%d h=%d cli=%d"), 
        bufSize, (TInt)this, (TInt)&iClient );
#endif
    iArgs.Set( 0, &iEventData );
    iArgs.Set( 1, &iPtrStore->iPtr ); 
    iArgs.Set( 2, bufSize );
    iClient.SendReceive( EImpsServEventBody, iArgs, iStatus );
    }

// ----------------------------------------------------------------------------
// CImpsHandler2::ResetBuffers()
// ----------------------------------------------------------------------------
void CImpsHandler2::ResetBuffers()
    {
    delete iPtrStore;
    iPtrStore = NULL;
    delete iBody;
    iBody = NULL;
    }

//  End of File