/*
* Copyright (c) 2002-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:  SRCS session handler. Dispatchs requests from
*                clients and serves them.
*
*/



// INCLUDE FILES

#include "SrcsSession.h"
#include "obexsm.h"
#include "SrcsMessage.h"
#include "debug.h"
#include <btfeaturescfg.h>


// CONSTANTS

// The granularity of the array used to hold CSrcsMessage objects
static const TInt KMessageArrayGranularity = 4;



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

// ---------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// constructor - must pass client to CSession2
// ---------------------------------------------------------
//
CSrcsSession::CSrcsSession(CObexSM* aServer) : CSession2(),
                                            iServer(aServer),
                                            iCanceling(EFalse)
    {
    if(iServer)
        {    
        iServer->IncSessionCount();
        }
    }
// ---------------------------------------------------------
// destructor
// ---------------------------------------------------------
//
CSrcsSession::~CSrcsSession()
    {
    FLOG(_L("[SRCS]\tserver\tCSrcsSession closed."));
    if ( iMessageArray )
        {
        // Cleanup the array
        iMessageArray->ResetAndDestroy();
        }
    delete iMessageArray;
    if(iServer)
        {    
        iServer->DecSessionCount();
        } 
    }
// ---------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------
//
CSrcsSession* CSrcsSession::NewL(CObexSM* aServer)
    {
    return new(ELeave) CSrcsSession(aServer);
    }

// ---------------------------------------------------------
// Server
// Return a reference to CSrcs
// ---------------------------------------------------------
CObexSM& CSrcsSession::Server()
    {
    return *iServer;
    }

// ---------------------------------------------------------
// CreateL
// 2nd phase construct for sessions
// - called by the CServer framework
// ---------------------------------------------------------
void CSrcsSession::CreateL()
    {
    // Add session to server first.
    // If anything leaves, it will be removed by the destructor
    ConstructL();
    }

// ---------------------------------------------------------
// ConstructL
// 2nd phase construct for sessions
// - called by the CServer framework
//
// ---------------------------------------------------------
void CSrcsSession::ConstructL()
    {
    iMessageArray = new(ELeave) CArrayPtrFlat<CSrcsMessage>(KMessageArrayGranularity);
    }

// ---------------------------------------------------------
// HandleError
// Handle an error from ServiceL()
// A bad descriptor error implies a badly programmed client, so panic it;
// otherwise report the error to the client
//
// ---------------------------------------------------------
void CSrcsSession::HandleError(TInt aError, const RMessage2& aMessage)
    {
    FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession::HandleError(): %d"), aError));
    if (aError==KErrBadDescriptor)
        {
        PanicClient( aMessage, ESrcsBadDescriptor);
        }
    else
        {
        CompleteMessage( aMessage, aError);
        }
    }


// ---------------------------------------------------------
// ServiceL
// Calls DispatchMessage under trap harness
//
// ---------------------------------------------------------
void CSrcsSession::ServiceL(const RMessage2& aMessage)
    {
    // First make our own message from RMessage2
    // TRAP because message needs to be completed
    // in case of Leave.        
    TRAPD( err, CreateSrcsMessageL( aMessage ));
    if ( err )
        {
        FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession: ServiceL. Error %d when creating message."), err));
        aMessage.Complete( err );
        }
    else
        {
        err = KErrNone;
        TRAP( err ,DispatchMessageL( aMessage ));

        // If we have an error, try to handle it with handle-error.
        if ( err )
            {
            HandleError( err, aMessage );
            }
        }
    }

// ---------------------------------------------------------
// CreateSrcsMessageL
// Creates a CSrcsMessage and appends it to iMessageArray.
// ---------------------------------------------------------
//
void CSrcsSession::CreateSrcsMessageL(const RMessage2& aMessage)
    {
    __ASSERT_DEBUG(iMessageArray!=NULL, PanicServer(ESrcsClassMemberVariableIsNull));
    CSrcsMessage* message = CSrcsMessage::NewL(aMessage);
    CleanupStack::PushL( message );
    iMessageArray->AppendL( message );
    CleanupStack::Pop();
    FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession: MessageArray count: %d"), iMessageArray->Count()));
    }

// ---------------------------------------------------------
// CompleteMessage
// Finds a message based on aMessage and completes it.
// ---------------------------------------------------------
//
void CSrcsSession::CompleteMessage(const RMessage2& aMessage, TInt aReason)
    {
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: CompleteMessage."));
    CSrcsMessage* message = FindMessage(aMessage);
    __ASSERT_DEBUG(message!=NULL, PanicServer(ESrcsBadMessage));
    message->Complete(aReason);
    DeleteMessage( message );
    }

// ---------------------------------------------------------
// CompleteMessage
// Completes given message.
// ---------------------------------------------------------
//
void CSrcsSession::CompleteMessage(CSrcsMessage* aMessage, TInt aReason)
    {
    __ASSERT_DEBUG(aMessage!=NULL, PanicServer(ESrcsBadMessage));
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: CompleteMessage."));
    aMessage->Complete(aReason);
    DeleteMessage(aMessage);
    }

// ---------------------------------------------------------
// CompletePendingMessages
// Completes any messages pending in the CBTManMessage array.
// ---------------------------------------------------------
void CSrcsSession::CompletePendingMessages()
    {
    __ASSERT_DEBUG(iMessageArray!=NULL, PanicServer(ESrcsClassMemberVariableIsNull));
    CSrcsMessage* messagePtr = NULL;
    TInt count = iMessageArray->Count();
    FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession::CompletePendingMessages. Message count: %d"), count));

    // Messages can be completed from array
    // and deleted after that.
    for ( TInt index = ( count-1 ) ; index >= 0 ; index-- )
        {
        messagePtr = iMessageArray->At(index);
        messagePtr->Complete(KErrDied);
        iMessageArray->Delete(index);
        delete messagePtr;
        messagePtr = NULL;
        }
    }

// ---------------------------------------------------------
// FindMessage
// Searches the array of CBTManMessages for the one dealing with aMessage.
// ---------------------------------------------------------
//
CSrcsMessage* CSrcsSession::FindMessage(const RMessage2& aMessage)
    {
    __ASSERT_DEBUG(iMessageArray!=NULL, PanicServer(ESrcsClassMemberVariableIsNull));
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: FindMessage."));
    RMessagePtr2 messagePtr = aMessage;
    CSrcsMessage* ptr = NULL;

    for ( TInt index = 0 ; index < iMessageArray->Count() ; index++ )
        {
        ptr = iMessageArray->At( index );
        if( ptr->MessagePtr() == messagePtr )
            {
            FLOG(_L("[SRCS]\tserver\tCSrcsSession: FindMessage. Message found"));
            return ptr;
            }
        }
    return NULL;
    }

// ---------------------------------------------------------
// FindMessage
// Searches the array for the 1st message with the function.
// ---------------------------------------------------------
//
CSrcsMessage* CSrcsSession::FindMessage(TInt aFunction)
    {
    __ASSERT_DEBUG(iMessageArray!=NULL, PanicServer(ESrcsClassMemberVariableIsNull));
    FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession: FindMessage aFunction %d"), aFunction));
    CSrcsMessage* ptr = NULL;
    for ( TInt index = 0 ; index < iMessageArray->Count() ; index++ )
        {
        ptr = iMessageArray->At( index );
        if ( ptr->MessagePtr().Function() == aFunction )
            {
            FLOG(_L("[SRCS]\tserver\tCSrcsSession: FindMessage. Message found"));
            return ptr;
            }
        }
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: FindMessage. Message not found"));
    return NULL;
    }

// ---------------------------------------------------------
// DeleteMessage
// Find the CSrcsMessage in the message array and delete it.
// ---------------------------------------------------------
//
void CSrcsSession::DeleteMessage(CSrcsMessage* aMessage)
    {
    __ASSERT_DEBUG(iMessageArray!=NULL, PanicServer(ESrcsClassMemberVariableIsNull));
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: DeleteMessage. "));
    CSrcsMessage* ptr = NULL;
    TInt count = iMessageArray->Count();
    for ( TInt index = ( count-1 ) ; index >= 0 ; index-- )
        {
        ptr = iMessageArray->At( index );
        if( ptr == aMessage )
            {
            FLOG(_L("[SRCS]\tserver\tCSrcsSession: Message deleting. "));
            //Delete the message first before removing from the array since a helper associated
            //with the message will try to find the message by parsing the array as part of the
            //destruction the message.
            delete ptr;
            iMessageArray->Delete( index );
            ptr = NULL;
            break;
            }
        }
    FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession: MessageArray count: %d"), iMessageArray->Count()));
    //compress the array if the count is less than the length - granularity AND if the count != 0
    if ( iMessageArray->Count() )
        {
        if (iMessageArray->Length() - iMessageArray->Count() >= KMessageArrayGranularity)
            iMessageArray->Compress();
        }
    }


// ---------------------------------------------------------
// DispatchMessageL
// service a client request; test the opcode and then do
// appropriate servicing
// ---------------------------------------------------------
//
void CSrcsSession::DispatchMessageL(const RMessage2 &aMessage)
    {
    FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession: DispatchMessageL function %d"), aMessage.Function()));
    iCanceling=EFalse;
    switch (aMessage.Function())
        {
        // Turn BT services ON (with service handler).
    case ESrcsBTServicesON:
            {
			if ( BluetoothFeatures::EnterpriseEnablementL() != BluetoothFeatures::EEnabled )
				{
				CompleteMessage(aMessage, KErrNotSupported);
				}
			else
				{			
	            ManageServices(ESrcsTransportBT, ETrue, aMessage);
				}
            break;
            }
        // Turn BT services OFF.
    case ESrcsBTServicesOFF:
            {
            ManageServices(ESrcsTransportBT, EFalse, aMessage);
            break;
            }

        // Turn IrDA services ON (with service handler).
    case ESrcsIrDAServicesON:
            {
            ManageServices(ESrcsTransportIrDA, ETrue, aMessage);
            break;
            }
        // Turn IrDA services OFF.
    case ESrcsIrDAServicesOFF:
            {
            ManageServices(ESrcsTransportIrDA, EFalse, aMessage);
            break;
            }

    case ESrcsStartUSB:
            {
            ManageServices(ESrcsTransportUSB, ETrue, aMessage);
            break;
            }
    case ESrcsStopUSB:
            {
            ManageServices(ESrcsTransportUSB, EFalse, aMessage);
            break;
            }    
     case ESrcsCancelRequest:
            {            
            FLOG(_L("[SRCS]\tserver\tCSrcsSession: DispatchMessageL: ESrcsCancelRequest"));
            CancelingRequest(aMessage);
            break;
            }
    default:
            {
            PanicClient( aMessage, ESrcsBadRequest);
            break;
            }
        }
    }

// ---------------------------------------------------------
// ManageServicesL
// OpCode function; Manages Services.
// ---------------------------------------------------------
//
void CSrcsSession::ManageServices(TSrcsTransport aTransport, TBool aState, 
                                  const RMessage2& aMessage)
    {
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: ManageServicesL"));
    TInt retVal = Server().ManageServices(aTransport, aState, this, aMessage);
    FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession: ManageServicesL return %d"), retVal));
    }

// ---------------------------------------------------------
// CancelingRequest
// Canceling the ongoing request.
// ---------------------------------------------------------
//
void CSrcsSession::CancelingRequest(const RMessage2& aMessage)
    {
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: CancelingRequest"));
    iCanceling=ETrue;          
    if (iMessageArray->Count() == 1)
        {
        FLOG(_L("[SRCS]\tserver\tCSrcsSession: CancelingRequest completing"));
        CompleteMessage(aMessage, KErrGeneral);        
        }
    else
        {
        //The cancel handling continues, when another request completes.
        }
    }
    
// ---------------------------------------------------------
// RequestCompleted
// ---------------------------------------------------------
//   
void CSrcsSession::RequestCompleted(const RMessage2 &aMessage, TInt aError)
    {          
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: RequestCompleted"));
    TBool postponeCompletion = EFalse;
    if ( !iCanceling )
        {
        FLOG(_L("[SRCS]\tserver\tCSrcsSession: RequestCompleted completing"));
        CompleteMessage( aMessage, aError ); 
        }
    else
        {
        CompleteCanceling(aMessage, aError, postponeCompletion);
        }
    if ( !postponeCompletion && iMessageArray->Count() > 0 )
        {
        FLOG(_L("[SRCS]\tserver\tCSrcsSession: RequestCompleted dispatching"));
        CSrcsMessage* messagePtr = NULL; 
        messagePtr=iMessageArray->At( 0 ); 
        RMessage2 message=messagePtr->MessagePtr(); 
        TRAP_IGNORE( DispatchMessageL( message ) );
        }    
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: RequestCompleted exit"));
    }

// ---------------------------------------------------------
// CompleteCanceling
// Only USB service cancel is handled, since Locod Service 
// Plugin API does not allow cancel for BT or IrDA.
// ---------------------------------------------------------
//
void CSrcsSession::CompleteCanceling(const RMessage2& aMessage, TInt aError, 
                                     TBool& aPostponeCompletion)
    {          
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: CompleteCanceling"));
    TBool cancelMsgFound = EFalse;
    CSrcsMessage* messagePtr = NULL;
    FTRACE(FPrint(_L("[SRCS]\tserver\tCSrcsSession: CompleteCanceling function %d"), 
        aMessage.Function()));
    switch ( aMessage.Function() )
        {    
        case ESrcsStartUSB:
            messagePtr = FindMessage(ESrcsCancelRequest);
            if ( messagePtr )
                {
                FLOG(_L("[SRCS]\tserver\tCSrcsSession: CompleteCanceling ESrcsStartUSB found cancel req"));
                RMessage2 message=messagePtr->MessagePtr();                
                ManageServices(ESrcsTransportUSB, EFalse,  message);
                aPostponeCompletion = ETrue;
                cancelMsgFound = ETrue;
                }
            break;
        case ESrcsStopUSB:
            messagePtr = FindMessage(ESrcsCancelRequest);
            if ( messagePtr )
                {
                CompleteMessage(aMessage, KErrCancel); 
                CompleteMessage(messagePtr, aError); 
                cancelMsgFound = ETrue;
                }
            break;
        case ESrcsCancelRequest:
            //either start or stop USB
            messagePtr = FindMessage(ESrcsStartUSB);
            if ( !messagePtr )
                {
                messagePtr = FindMessage(ESrcsStopUSB);
                }
            if ( messagePtr )
                {
                CompleteMessage(messagePtr, KErrCancel); 
                CompleteMessage(aMessage, aError);
                cancelMsgFound = ETrue;
                }
            break;
        default:
            FLOG(_L("[SRCS]\tserver\tCSrcsSession: CompleteCanceling ESrcsCancelRequest unhandled msg"));
            break;
        }
    if ( !cancelMsgFound )
        {
        FLOG(_L("[SRCS]\tserver\tCSrcsSession: CompleteCanceling no message"));
        CompleteMessage(aMessage, KErrGeneral);
        }
    FLOG(_L("[SRCS]\tserver\tCSrcsSession: CompleteCanceling exit"));    
    }
// End of File