/*

* Copyright (c) 2006 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:   Implementation of CCatalogsClientServerServerSession

*

*/

#include <e32kpan.h>

#include "catalogsclientserverserversession.h"

#include "catalogsserverdefines.h"

#include "catalogscommunicable.h"

#include "catalogsbasemessageimpl.h"

#include "catalogsincompletemessage.h"

#include "catalogscontextimpl.h"

#include "catalogsdebug.h"

// ======== LOCAL FUNCTIONS ========

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

// Cleanupfunction for cleanupitem usage. Closes CObject based

// object as many times as needed to destroy it when removed

// from cleanupstack.

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

//    

void CCatalogsClientServerServerSession::CleanupCObjectBasedClass( TAny* aCObject )

	{

	CObject* convertedCObject = ( static_cast< CObject* > ( aCObject ) );

	TInt accessCount = convertedCObject->AccessCount();

    while ( accessCount > 0 )

        {

        convertedCObject->Close();

        --accessCount;

        }

    // Now that last reference is closed, aCObject is destroyed

	}

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

CCatalogsClientServerServerSession* CCatalogsClientServerServerSession::NewL(

    RThread& aClient,

    CCatalogsClientServerServer& aServer )

    {

    CCatalogsClientServerServerSession* self = 

        CCatalogsClientServerServerSession::NewLC( aClient, aServer );

    CleanupStack::Pop(self) ;

    return self ;

    }

CCatalogsClientServerServerSession* CCatalogsClientServerServerSession::

    NewLC( RThread& aClient, CCatalogsClientServerServer& aServer )

    {

    CCatalogsClientServerServerSession* self = 

        new (ELeave) CCatalogsClientServerServerSession( aClient, aServer,

            aServer.NewInstanceId() );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CCatalogsClientServerServerSession::CCatalogsClientServerServerSession(

    RThread& /*aClient*/,

    CCatalogsClientServerServer& aServer,

    TInt aInstanceId ) :

    CSession2(),

    iClientSideDownAnnounced( ENotInformed ),

    iServer( aServer ),

    iInstanceId( aInstanceId )

    {

    }

CCatalogsClientServerServerSession::~CCatalogsClientServerServerSession()

    {

    DLTRACEIN((""));

    ClientSideSessionDown();   

    DLTRACE(("Deleting context")); 

    delete iContext;

    iServer.DecrementSessions();    

    DLTRACEOUT((""));

    }

void CCatalogsClientServerServerSession::ConstructL() 

    {    

    iServer.IncrementSessions();

    iMessageHandlers = CObjectIx::NewL();

    iIncompleteMessageContainer = iServer.NewContainerL();

    iIncompleteMessages = CObjectIx::NewL();

    }

void CCatalogsClientServerServerSession::ClientSideSessionDown()

    {

    DLTRACEIN((""));

    if ( iClientSideDownAnnounced == ENotInformed )

        {

        DLTRACE(("Delete incomplete messages"));

        // Incomplete messages act as receivers of messages as well

        // as nodes etc.

        delete iIncompleteMessages;

        iIncompleteMessages = NULL;

        // In examples, container is simply deleted, but here

        // this ends up making a KERN-EXEC 3. Probably container is 

        // removed for a second time when the container-index is removed.

        if ( iIncompleteMessageContainer != NULL )

            {

            DLTRACE(("Remove container"));

            iServer.RemoveContainer( iIncompleteMessageContainer );

            DLTRACE(("Container removed"));

            }

        iIncompleteMessageContainer = NULL;

        CloseMessageHandlers();

        DLTRACE(("Handle session removal"));

        // Inform possibly interested objects of session removal

        // so they know that this session does not exist anymore

        iServer.HandleSessionRemoval( *this );

        iClientSideDownAnnounced = EInformed;        

        }

    DLTRACEOUT((""));

    }

TInt CCatalogsClientServerServerSession::WriteToLargerDesL(

    const TDesC8& aOutputData,

    TInt aStatus )

    {

    CCatalogsIncompleteMessage* incompleteMessage =

        CCatalogsIncompleteMessage::NewL();

    // NOTICE: Because a CObject-derived object cannot be deleted

    //         when its reference count is not zero, we use a

    //         cleanup-item. Another way could be to do it in the

    //         destructor of the CObject-derived object, but

    //         it could enable unintended destruction of the object.?

    TCleanupItem cleanupCObjectInfo( CleanupCObjectBasedClass,

                                 incompleteMessage );

    CleanupStack::PushL( cleanupCObjectInfo );    

    incompleteMessage->SetMessageL( aOutputData, aStatus );

    iIncompleteMessageContainer->AddL( incompleteMessage );

    TInt handle = iIncompleteMessages->AddL( incompleteMessage );

    CleanupStack::Pop( incompleteMessage );

    return handle;

    }

TInt CCatalogsClientServerServerSession::WriteToLargerDesL(

    const TDesC16& aOutputData,

    TInt aStatus )

    {

    CCatalogsIncompleteMessage* incompleteMessage =

        CCatalogsIncompleteMessage::NewL();

    // NOTICE: Because a CObject-derived object cannot be deleted

    //         when its reference count is not zero, we use a

    //         cleanup-item. Another way could be to do it in the

    //         destructor of the CObject-derived object, but

    //         it could enable unintended destruction of the object.?

    TCleanupItem cleanupCObjectInfo( CleanupCObjectBasedClass,

                                 incompleteMessage );

    CleanupStack::PushL( cleanupCObjectInfo );

    incompleteMessage->SetMessageL( aOutputData, aStatus );

    iIncompleteMessageContainer->AddL( incompleteMessage );

    TInt handle = iIncompleteMessages->AddL( incompleteMessage );

    CleanupStack::Pop( incompleteMessage );

    return handle;

    }

void CCatalogsClientServerServerSession::RemoveIncompleteMessage( TInt aHandle )

    {

    iIncompleteMessages->Remove( aHandle );

    }

void CCatalogsClientServerServerSession::ServiceL( const RMessage2& aMessage )

    {

    DLTRACEIN((""));

    // If ServiceL leaves, the framework calls ServiceError which by default

    // completes the message with the leave code if it has not been completed

    // yet

    HandleMessageL( aMessage );

    }

TInt CCatalogsClientServerServerSession::AddObjectL(

    CObject* aObject )

    {

    iServer.AddObjectToContainerL( aObject );

    TInt handle( iMessageHandlers->AddL( aObject ) );

    // Because add to the ix does not call Open() of the CObject,

    // we have to do it ourselves

    User::LeaveIfError( aObject->Open() );

    return handle;

    }

void CCatalogsClientServerServerSession::RemoveObject( TInt aHandle )

    {

    // This closes the CObject once.

    iMessageHandlers->Remove( aHandle );

    }

MCatalogsContext& CCatalogsClientServerServerSession::Context()

    {

    return *iContext;

    }

const MCatalogsContext* CCatalogsClientServerServerSession::ContextPtr() const

    {

    return iContext;

    }

void CCatalogsClientServerServerSession::HandleMessageL(

    const RMessage2& aMessage )

    {

    DLTRACEIN(("Function: %X", aMessage.Function() ));

    // NOTICE: If aMessage has to be stored and used later

    //         then copy it and use the copy instead.

    if ( iClientSideDownAnnounced == EInformed )

        {

        // Do not communicate to client anymore

        // client-side session is going down

        return;

        }

    else if( ( aMessage.Function() != ECatalogsCreateContext ) 

             && ( iContext == NULL ) )

        {

        DLERROR(( "Completing message with KErrNotReady" ));

        aMessage.Complete( KErrNotReady );

        }

    if( aMessage.Function() == ECatalogsExternalMessage 

        || aMessage.Function() == ECatalogsExternalAllocMessage )

        {

        HandleExternalMessageL( aMessage );

        }

    else

        {

        HandleInternalMessageL( aMessage );

        }

    DLTRACEOUT((""));

    }

void CCatalogsClientServerServerSession::HandleExternalMessageL(

    const RMessage2& aMessage )

    {

    DLTRACEIN((""));

    TPckgBuf<TInt> handle;

    aMessage.ReadL( 1, handle );

    CCatalogsCommunicable* receiver = ReceiverFromHandle( handle() );

    DLTRACE(("Receiver for message: %X", receiver ));

    if( !receiver )

        {

        PanicClient( aMessage, EBadHandle );

        return;

        }

    CCatalogsBaseMessageImpl* baseMessage = 

        CCatalogsBaseMessageImpl::NewLC( aMessage,

                                         *this,

                                         handle() );

    TPckgBuf<TInt> funcNumber;

    aMessage.ReadL( 0, funcNumber );

    CleanupStack::Pop( baseMessage );

    DLTRACE(("Passing message"));

    // Now the message is already passed to the receiver

    // and it is its duty to use it to inform of possible

    // error situations

    //      -> Nothing is done here            

    receiver->ReceiveMessage( baseMessage, funcNumber() );

    DLTRACEOUT(("Message passed"));    

    }

void CCatalogsClientServerServerSession::HandleInternalMessageL(

    const RMessage2& aMessage )

    {

    DLTRACEIN((""));

    switch( aMessage.Function() )

        {

        case ECatalogsCompleteMessage:

            {

            DLTRACE(("ECatalogsCompleteMessage"));

            TPckgBuf<TInt> handle;

            aMessage.ReadL( 1, handle );

            CCatalogsIncompleteMessage* incompleteMessage =

                IncompleteMessageFromHandle( handle() );

            if( !incompleteMessage )

                {

                PanicClient( aMessage, EBadHandle );

                return;

                }

            const TDesC8& message = incompleteMessage->Message();

            TInt returnValue = incompleteMessage->ReturnValue();

            DLINFO(( "Writing message" ));

            TRAPD( error, aMessage.WriteL( 3, message ) );                        

            if ( error != KErrNone )

                {

                RemoveIncompleteMessage( handle() );

                User::Leave( error );

                }

            DLINFO(( "Completing message with %d", returnValue ));

            aMessage.Complete( returnValue );

            RemoveIncompleteMessage( handle() );            

            break;

            }

        case ECatalogsCompleteMessageWide:

            {

            DLTRACE(("ECatalogsCompleteMessageWide"));

            TPckgBuf<TInt> handle;

            aMessage.ReadL( 1, handle );

            CCatalogsIncompleteMessage* incompleteMessage =

                IncompleteMessageFromHandle( handle() );

            if( !incompleteMessage )

                {

                PanicClient( aMessage, EBadHandle );

                return;

                }

            const TDesC16& message = incompleteMessage->MessageWide();

            TInt returnValue = incompleteMessage->ReturnValue();

            DLINFO(( "Writing message" ));

            TRAPD( error, aMessage.WriteL( 3, message ) );

            if ( error != KErrNone )

                {

                RemoveIncompleteMessage( handle() );

                User::Leave( error );

                }

            DLINFO(( "Completing message with %d", returnValue ));

            aMessage.Complete( returnValue );

            RemoveIncompleteMessage( handle() );

            break;

            }

        case ECatalogsRemoveIncompleteMessage:

            {

            DLTRACE(("ECatalogsRemoveIncompleteMessage"));

            TPckgBuf<TInt> handle;

            aMessage.ReadL( 1, handle );

            RemoveIncompleteMessage( handle() );

            DLINFO(( "Completing message with KErrNone" ));

            aMessage.Complete( KErrNone );

            break;

            }

        case ECatalogsClientSideDown:

            {

            DLTRACE(("ECatalogsClientSideDown"));

            ClientSideSessionDown();

            DLINFO(( "Completing message with KErrNone" ));

            aMessage.Complete( KErrNone );

            break;

            }

        case ECatalogsCreateProvider:

            {

            DLTRACE(("Create Provider"));

            CreateProviderL( aMessage );

            DLTRACE(("Create Provider done"));

            break;

            }

        case ECatalogsCreateContext:

            {

            DLTRACE(("ECatalogsCreateContext"));

            CreateContextL( aMessage );

            break;

            }

        default:

            {

            }

        }    

    }

void CCatalogsClientServerServerSession::CreateProviderL(

    const RMessage2& aMessage )

    {

    DLTRACEIN((""));

    TInt providerUid = aMessage.Int0();

    TUint32 providerOptions = aMessage.Int2();

    // We have to have a integer which contains the handle to be

    // able to write it into client side later.

    TInt tempHandle( 0 );

    TRAPD( outcome,

        iServer.CreateProviderL( 

            *this, providerUid, tempHandle, providerOptions ) );

    // KErrNone and positive codes are a success. Cache cleaning

    // can cause positive leaves

    if ( outcome >= KErrNone ) 

        {

        DLTRACE(("Writing the provider handle to the message"));

        TPckgBuf<TInt> handleBuf( tempHandle );

        TRAPD( err, aMessage.WriteL( 1, handleBuf ) );

        if ( err != KErrNone )

            {

            DLTRACE(("Couldn't pass the handle back"));

            // If we can't pass the handle back, there is no use

            // to try to continue normally.

            RemoveObject( tempHandle );

            outcome = err;

            }

        }

    DLTRACE(("Completing message with: %d", outcome ));    

    aMessage.Complete( outcome );    

    }

void CCatalogsClientServerServerSession::CreateContextL(

    const RMessage2& aMessage )

    {

    DLTRACEIN((""));

    if ( iContext != NULL )

        {

        DLERROR(( "Completing message with KErrAlreadyExists" ));

        aMessage.Complete( KErrAlreadyExists );

        return;

        }

    TInt familyIdTint = aMessage.Int0();

    TUid familyIdUid = TUid::Uid( familyIdTint );    

    TSecureId secureId = aMessage.SecureId();

    iContext = CCatalogsContextImpl::NewL( familyIdUid, secureId, iInstanceId );

    // cancel shutdown operations for this family

    iServer.OperateShutdownOperations( Context(), EFalse );

    DLINFO(( "Completing message with KErrNone" ));

    aMessage.Complete( KErrNone );

    DLTRACEOUT((""));

    }

void CCatalogsClientServerServerSession::PanicClient(

    const RMessage2& aMessage, TInt aPanic ) const

    {

    DLTRACEIN((""));

    // NOTICE: KTxtCatalogsSession should not exceed 16 characters.

    //         If it does, it will result in USER 23. So it seems

    //         that RMEssage2::Panic does not truncate the characters

    //         that exceed those 16 characters.

    _LIT( KTxtCatalogsSession,"CCatalogsSession" );

    aMessage.Panic( KTxtCatalogsSession, aPanic );

    }

CCatalogsCommunicable* 

    CCatalogsClientServerServerSession::ReceiverFromHandle( TInt aHandle )

    {

    DLTRACEIN((""));

    if ( iMessageHandlers == NULL )

        {

        return NULL;

        }

    // Normal situation

    CCatalogsCommunicable* handler = 

        static_cast<CCatalogsCommunicable*>( iMessageHandlers->At( aHandle ) );

	DLTRACEOUT((""));

    return handler;

    }

CCatalogsIncompleteMessage* 

    CCatalogsClientServerServerSession::IncompleteMessageFromHandle( TInt aHandle )

    {

    DLTRACEIN((""));

    if ( iIncompleteMessages == NULL )

        {

        return NULL;

        }

    // Normal situation    

    CCatalogsIncompleteMessage* message =

        static_cast<CCatalogsIncompleteMessage*>( 

            iIncompleteMessages->At( aHandle ) ); 

    DLTRACEOUT((""));

    return message;   

    }

void CCatalogsClientServerServerSession::CloseMessageHandlers()

    {

    DLTRACEIN((""));

    TInt communicableCount( iMessageHandlers->Count() );