/*
* Copyright (c) 2006-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:  Message handler context class implementation.
*
*/


#include <s32mem.h>

#include "CFMessageHandlerAction.h"
#include "cfcommon.h"
#include "CFActionInterface.h"
#include "CFActionSubscriptionImpl.h"
#include "CFActionIndicationImpl.h"
#include "CFServSession.h"
#include "cftrace.h"

// CONSTANTS

#ifdef _DEBUG

LOCAL_C void Panic( const RMessage2& aMessage, TInt aCode )
    {
    CCFServSession::PanicClient( aMessage, aCode );
    }

#endif

CCFMessageHandlerAction* CCFMessageHandlerAction::NewL(
	MCFExtendedContextInterface& aCFContext,
    MCFActionInterface& aCFAction,
    MCFScriptInterface& aScriptInterface )
    {
    FUNC_LOG;
    
    CCFMessageHandlerAction* self = CCFMessageHandlerAction::NewLC(
        aCFContext,
        aCFAction,
        aScriptInterface );
    CleanupStack::Pop( self );
    
    return self;
    }

CCFMessageHandlerAction* CCFMessageHandlerAction::NewLC(
	MCFExtendedContextInterface& aCFContext,
    MCFActionInterface& aCFAction,
    MCFScriptInterface& aScriptInterface )
    {
    FUNC_LOG;
    
    CCFMessageHandlerAction* self = new( ELeave ) CCFMessageHandlerAction(
        aCFContext,
        aCFAction,
        aScriptInterface );
    CleanupStack::PushL( self );
    self->ConstructL();
    
    return self;
    }

CCFMessageHandlerAction::~CCFMessageHandlerAction()
    {
    FUNC_LOG;
    
    if( !iSubscriptionListenMessage.IsNull() )
        {
        // Need to complete message
        iSubscriptionListenMessage.Complete( KErrCancel );
        }
    iCFAction.UnsubscribeActions( *this );
    iCFAction.DeregisterActions( this );
    iActionQueue.ResetAndDestroy();
    delete iCurrentAction;
    }

CCFMessageHandlerAction::CCFMessageHandlerAction(
	MCFExtendedContextInterface& aCFContext,
    MCFActionInterface& aCFAction,
    MCFScriptInterface& aScriptInterface ):
    CCFMessageHandlerBase( aCFContext, aCFAction, aScriptInterface )
    {
    FUNC_LOG;
    }
    
void CCFMessageHandlerAction::ConstructL()
    {
    FUNC_LOG;
    }

// METHODS

//-----------------------------------------------------------------------------
// CCFMessageHandlerAction::HandleMessageL
//-----------------------------------------------------------------------------
//
TBool CCFMessageHandlerAction::HandleMessageL( const RMessage2& aMessage )
    {
    FUNC_LOG;

    TBool handled = ETrue;
    switch( aMessage.Function() )
        {
        // Slot[0] = TDesC
        // Slot[1] = TSecurityPolicyBuf
        case EDefineAction:
            {
            INFO( "Handling IPC message [EDefineAction]" );
            
            // Read action identifier
            HBufC* actionId = HBufC::NewLC( aMessage.GetDesLengthL( 0 ) );
            TPtr actionIdPtr = actionId->Des();
            aMessage.ReadL( 0, actionIdPtr );
            
            // Read security policy
            TSecurityPolicyBuf secPolicyBuf;
            aMessage.ReadL( 1, secPolicyBuf );
            TSecurityPolicy secPolicy;
            User::LeaveIfError( secPolicy.Set( secPolicyBuf ) );
            
            // Get client thread
            RThread client;
            aMessage.ClientL( client );
            CleanupClosePushL( client );
            
            // Define action
            TInt err = iCFAction.DefineAction( actionIdPtr, secPolicy,
                client.SecureId(), this );
            
            // Cleanup
            CleanupStack::PopAndDestroy( &client );
            CleanupStack::PopAndDestroy( actionId );
            
            // Complete message and return
            aMessage.Complete( err );
            
            INFO( "Handled IPC message [EDefineAction]" );
            
            break;
            }

        // Slot[0] = TDesC - CCFActionSubscription
        case ESubscribeAction:
            {
            INFO( "Handling IPC message [ESubscribeAction]" );
            
            // Read subscription
            // Start with buffer
            HBufC8* buf = HBufC8::NewLC( aMessage.GetDesLengthL( 0 ) );
            TPtr8 bufPtr = buf->Des();
            aMessage.ReadL( 0, bufPtr );
            
            // Open stream and fetch client thread
            RDesReadStream stream;
            stream.Open( bufPtr );
            stream.PushL();
            RThread client;
            aMessage.ClientL( client );
            CleanupClosePushL( client );
            
            // Create subscription from stream
            CCFActionSubscriptionImpl* subscription = static_cast
                <CCFActionSubscriptionImpl*>( CCFActionSubscription::NewLC() );
            subscription->InternalizeL( stream );
            CleanupStack::Pop( subscription );
            
            // Set subscription
            TInt err = iCFAction.SubscribeAction( subscription, this, client );

            // Cleanup
            CleanupStack::PopAndDestroy( &client );
            CleanupStack::PopAndDestroy( &stream );
            CleanupStack::PopAndDestroy( buf );

            // Complete message and return
            aMessage.Complete( err );

            INFO( "Handled IPC message [ESubscribeAction]" );
            
            break;
            }

        // Slot[0] = TDesC - CCFActionSubscription
        case EUnsubscribeAction:
            {
            INFO( "Handling IPC message [EUnsubscribeAction]" );
            
            // Read subscription
            // Start with buffer
            HBufC8* buf = HBufC8::NewLC( aMessage.GetDesLengthL( 0 ) );
            TPtr8 bufPtr = buf->Des();
            aMessage.ReadL( 0, bufPtr );
            
            // Open stream and fetch client thread
            RDesReadStream stream;
            stream.Open( bufPtr );
            stream.PushL();
            RThread client;
            aMessage.ClientL( client );
            CleanupClosePushL( client );
            
            // Create subscription from stream
            CCFActionSubscriptionImpl* subscription = static_cast
                <CCFActionSubscriptionImpl*>( CCFActionSubscription::NewLC() );
            subscription->InternalizeL( stream );
            
            // Set subscription
            iCFAction.UnsubscribeAction( *subscription, *this );

            // Cleanup
            CleanupStack::PopAndDestroy( subscription );
            CleanupStack::PopAndDestroy( &client );
            CleanupStack::PopAndDestroy( &stream );
            CleanupStack::PopAndDestroy( buf );

            // Complete message and return
            aMessage.Complete( KErrNone );

            INFO( "Handled IPC message [EUnsubscribeAction]" );
            
            break;
            }
            
        // Slot[0] = TDesC - Action indication buffer
        // Slot[1] = TDesC - Buffer size if current too small
        case EListenActionSubscription:
            {
            INFO( "Handling IPC message [EListenActionSubscription]" );
            
            // Store message and check if there is action indication
            // waiting
            iSubscriptionListenMessage = aMessage;
            CheckActionQueueL();

            INFO( "Handled IPC message [EListenActionSubscription]" );
            
            break;
            }
            
        // Slot[0] = TDesC - Action indication buffer
        case EGetActionIndication:
            {
            INFO( "Handling IPC message [EGetActionIndication]" );

            TInt err = KErrNone;
            
            // check that we really have an action indication waiting
            if( iCurrentAction )
                {
                // Indicate current action to client
                // This should not fail since we are here with this op code
                // only if server side has requested client to increase buffer.
                HBufC8* buffer = ExternalizeIndicationLC( *iCurrentAction );
                TPtr8 bufferPtr = buffer->Des();
                
                // Write message
                aMessage.WriteL( 0, bufferPtr );
                
                // Cleanup
                CleanupStack::PopAndDestroy( buffer );
                
                // Current action processed, delete and zero
                delete iCurrentAction;
                iCurrentAction = NULL;
                }
            else
                {
                // No action indications found
                err = KErrNotFound;
                }
            
            // Complete message and return
            aMessage.Complete( err );

            INFO( "Handled IPC message [EGetActionIndication]" );
            
            break;
            }
            
        case ECancelListenActionSubscription:
            {
            INFO( "Handling IPC message [ECancelListenActionSubscription]" );
            
            // Check if subscription message has not been completed yet
            if( !iSubscriptionListenMessage.IsNull() )
                {
                iSubscriptionListenMessage.Complete( KErrCancel );
                }
            aMessage.Complete( KErrNone );

            INFO( "Handled IPC message [ECancelListenActionSubscription]" );
            
            break;
            }
            
        default:
            {
            // Message not handled
            handled = EFalse;
            break;
            }
        }
    
    return handled;
    }

//-----------------------------------------------------------------------------
// CCFMessageHandlerAction::ActionIndicationL
//-----------------------------------------------------------------------------
//
void CCFMessageHandlerAction::ActionIndicationL(
    CCFActionIndication* aIndication )
    {
    FUNC_LOG;
    
    INFO_1( "Received action indication: %S", &aIndication->Identifier() );

    // Append action indication in queue and check queue
    TInt err = iActionQueue.Append( aIndication );
    if( err == KErrNone )
        {
        CheckActionQueueL();
        }
    else
        {
        // Something odd happened, try to serve this indication
        // We still need to have request message pending
        if( !iSubscriptionListenMessage.IsNull() && !iCurrentAction )
            {
            iCurrentAction = aIndication;
            IndicateCurrentActionL();
            }
        else
            {
            // Cannot serve this, delete
            delete aIndication;
            }
        }
    }

//------------------------------------------------------------------------------
// CCFMessageHandlerAction::ActionOwner
//------------------------------------------------------------------------------
//
MCFActionOwner::TCFActionOwner CCFMessageHandlerAction::ActionOwner() const
    {
    FUNC_LOG;
    
    return MCFActionOwner::ECFExternalAction;
    }

//-----------------------------------------------------------------------------
// CCFMessageHandlerAction::CheckActionQueueL
//-----------------------------------------------------------------------------
//
void CCFMessageHandlerAction::CheckActionQueueL()
    {
    FUNC_LOG;
    
    // If we have:
    // - Actions in the queue
    // - Currently not processing any actions
    // - Listen message outstanding
    if( iActionQueue.Count() &&
        !iCurrentAction &&
        !iSubscriptionListenMessage.IsNull() )
        {
        // Get latest action
        iCurrentAction = iActionQueue[0];
        iActionQueue.Remove( 0 );
        
        // Indicate current action to client
        IndicateCurrentActionL();
        }
    }

//-----------------------------------------------------------------------------
// CCFMessageHandlerAction::IndicateCurrentActionL
//-----------------------------------------------------------------------------
//
void CCFMessageHandlerAction::IndicateCurrentActionL()
    {
    FUNC_LOG;
    
    __ASSERT_DEBUG( iCurrentAction,
        Panic( iSubscriptionListenMessage, ENoCurrentAction ) );
    
    // Check client buffer
    TInt err = KErrNone;
    CCFActionIndicationImpl* indication =
        static_cast<CCFActionIndicationImpl*>( iCurrentAction );
    TInt indicationSize = indication->Size();
    TInt clientBufSize = iSubscriptionListenMessage.GetDesMaxLengthL( 0 );
    if( indicationSize > clientBufSize )
        {
        // Client buffer too small
        // Write new buffer size in Slot[1]
        TPckgBuf<TInt> indicationSizeBuf( indicationSize );
        iSubscriptionListenMessage.WriteL( 1, indicationSizeBuf );
        err = KErrTooBig;
        }
    else
        {
        // Client buffer sufficient
        // Stream indication into descriptor
        HBufC8* buffer = ExternalizeIndicationLC( *indication );
        TPtr8 bufferPtr = buffer->Des();
        
        // Write message
        iSubscriptionListenMessage.WriteL( 0, bufferPtr );
        
        // Cleanup
        CleanupStack::PopAndDestroy( buffer );
        delete iCurrentAction;
        iCurrentAction = NULL;
        }
        
    // Complete message
    iSubscriptionListenMessage.Complete( err );
    }

//-----------------------------------------------------------------------------
// CCFMessageHandlerAction::ExternalizeIndicationL
//-----------------------------------------------------------------------------
//
HBufC8* CCFMessageHandlerAction::ExternalizeIndicationLC(
    CCFActionIndication& aIndication )
    {
    FUNC_LOG;
    
    CCFActionIndicationImpl& indication =
        static_cast<CCFActionIndicationImpl&>( aIndication );
    
    HBufC8* buffer = HBufC8::NewLC( indication.Size() );
    TPtr8 bufferPtr = buffer->Des();
    RDesWriteStream stream( bufferPtr );
    stream.PushL();
    indication.ExternalizeL( stream );
    
    // Cleanup
    CleanupStack::PopAndDestroy( &stream );
    
    return buffer;
    }