/*
* 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 BTEng server session handling
*
*/



#include <e32base.h>
#include "btengsrvsession.h"
#include "btengserver.h"
#include "btengsrvbbconnectionmgr.h"
#include "btengpairman.h"
#include "btengclientserver.h"
#include "debug.h"


/**  The message argument which holds the client event package. */
const TInt KBTEngEventSlot = 2;

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

// ---------------------------------------------------------------------------
// C++ default constructor
// ---------------------------------------------------------------------------
//
CBTEngSrvSession::CBTEngSrvSession()
:   CSession2()
    {
    }


// ---------------------------------------------------------------------------
// Symbian 2nd-phase constructor
// ---------------------------------------------------------------------------
//
void CBTEngSrvSession::ConstructL()
    {
    TRACE_FUNC_ENTRY
    
    //create queue for storing multiple connection events
    iConnectionEventQueue = new (ELeave) CDesC8ArraySeg(1);
    }


// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CBTEngSrvSession* CBTEngSrvSession::NewL()
    {
    CBTEngSrvSession* self = new( ELeave ) CBTEngSrvSession();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CBTEngSrvSession::~CBTEngSrvSession()
    {
    TRACE_FUNC_ENTRY
    if( !iNotifyConnMessage.IsNull() )
        {
        iNotifyConnMessage.Complete( KErrCancel );
        }
    CancelPairRequest();
    if( Server() )
        {
        Server()->RemoveSession( iAutoSwitchOff );
        }
    
    delete iConnectionEventQueue;
    
    TRACE_FUNC_EXIT
    }


// ---------------------------------------------------------------------------
// Complete the construction of the session.
// ---------------------------------------------------------------------------
//
void CBTEngSrvSession::CreateL()
    {
    TRACE_FUNC_ENTRY
    Server()->AddSession();
    }


// ---------------------------------------------------------------------------
// Notify the client of the connection event.
// ---------------------------------------------------------------------------
//
void CBTEngSrvSession::NotifyConnectionEvent(const TBTDevAddr aAddr, 
    TBTEngConnectionStatus aConnStatus, RBTDevAddrArray* aArray, TInt aErr)
    {
    TRACE_FUNC_ENTRY

    TRACE_INFO((_L("[BTEng]\t Informing client %d"), iNotifyConnMessage.Handle()));
    
    //package up connection event to send to the client
    TBTEngEventPkg pkg;
    pkg().iAddr = aAddr;
    pkg().iConnEvent = aConnStatus;
    pkg().iConflictsBuf.Zero();
    if (aArray)
        {
        TBTDevAddrPckgBuf addr;
        
        for (TInt i = 0; i < aArray->Count(); i++)
            {
            addr = (*aArray)[i];
            pkg().iConflictsBuf.Append(addr);
            }
        }
    
    TInt err = KErrNotFound;
    
    //if a client message is outstanding
    if (!iNotifyConnMessage.IsNull())
        {
        //complete the message prioritising the main error
        err = iNotifyConnMessage.Write(KBTEngEventSlot, pkg);
        aErr = (aErr != KErrNone) ? aErr : err;
        iNotifyConnMessage.Complete(aErr);
        }
    
    //if there is no client message outstanding or the write failed
    if (err != KErrNone)
        {
        //if the append fails we can't do anything with the error so ignore
        //it and let the event get dropped
        TRAP_IGNORE(iConnectionEventQueue->AppendL(pkg));
        }
    }

// ---------------------------------------------------------------------------
// Comfirm the caller if pairing request is completed in this invoke. 
// ---------------------------------------------------------------------------
//
TInt CBTEngSrvSession::CompletePairRequest( TInt aResult )
    {
    if ( !iPairMessage.IsNull())
        {
        iPairMessage.Complete( aResult );
        return KErrNone;
        }
    return KErrNotFound;
    }

// ---------------------------------------------------------------------------
// From class CSession2
// Handles servicing of a client request that has been passed to the server.
// ---------------------------------------------------------------------------
//
void CBTEngSrvSession::ServiceL( const RMessage2& aMessage )
    {
    TRAPD( err, DispatchMessageL( aMessage ) );

    if( !aMessage.IsNull() &&
        ( err || 
          ( aMessage.Function() != EBTEngNotifyConnectionEvents && 
            aMessage.Function() != EBTEngPairDevice ) ) )
        {
            // Return the error code to the client.
        aMessage.Complete( err );
        }
    }


// ---------------------------------------------------------------------------
// Returns a handle to CBTEngServer.
// ---------------------------------------------------------------------------
//
CBTEngServer* CBTEngSrvSession::Server()
    {
    return (CBTEngServer*) CSession2::Server();
    }


// ---------------------------------------------------------------------------
// Handles a client request that has been passed to the server.
// ---------------------------------------------------------------------------
//
void CBTEngSrvSession::DispatchMessageL( const RMessage2& aMessage )
    {
    TRACE_FUNC_ENTRY
    TInt opcode = aMessage.Function();
   
    switch( opcode )
        {
        case EBTEngSetPowerState:
            {
            iAutoSwitchOff = (TBool) aMessage.Int1();
            Server()->SetPowerStateL( (TBTPowerStateValue) aMessage.Int0(), 
                                       iAutoSwitchOff );
            }
            break;
        case EBTEngSetVisibilityMode:
            {
            Server()->SetVisibilityModeL( (TBTVisibilityMode) aMessage.Int0(),
                                           aMessage.Int1() );
            }
            break;
        case EBTEngNotifyConnectionEvents:
            {
            //ensure the message contains the correctly sized descriptor
            if (aMessage.GetDesMaxLengthL(KBTEngEventSlot) != sizeof(TBTEngEventMsg))
                {
                User::Leave(KErrBadDescriptor);
                }
            
            if(!iNotifyConnMessage.IsNull())
                {
                User::Leave(KErrInUse);
                }
            
            //save the client message
            iNotifyConnMessage = RMessage2(aMessage);
            
            //if there is an existing connection event that the client does
            //not yet know about
            if (iConnectionEventQueue->Count() > 0)
                {
                //complete straight away with package from queue
                TInt err = iNotifyConnMessage.Write(KBTEngEventSlot, (*iConnectionEventQueue)[0]);
                if (err == KErrNone)
                    {
                    iConnectionEventQueue->Delete(0);
                    }
                iNotifyConnMessage.Complete(err);
                }
            }
            break;
        case EBTEngCancelEventNotifier:
            {
            if( !iNotifyConnMessage.IsNull() )
                {
                iNotifyConnMessage.Complete( KErrCancel );
                }
            }
            break;
        case EBTEngConnectDevice:
        case EBTEngCancelConnectDevice:
        case EBTEngDisconnectDevice:
        case EBTEngIsDeviceConnected:
        case EBTEngGetConnectedAddresses:
            {
            TBTPowerStateValue pwr = EBTPowerOff;
            Server()->GetHwPowerState( pwr );
            if( pwr )
                {
                    // Simply forward it to the plug-in manager
                Server()->DispatchPluginMessageL( aMessage );
                }
            else
                {
                User::Leave( KErrNotReady );
                }
            }
            break;    
        case EBTEngIsDeviceConnectable:
            {
            Server()->DispatchPluginMessageL( aMessage );
            }
            break;
        case EBTEngPrepareDiscovery:
            {
            aMessage.Complete( KErrNone );  // Client does not have to wait.
            Server()->iBBConnMgr->ManageTopology( ETrue );
            }
            break;
        case EBTEngSetPairingObserver:
        case EBTEngPairDevice:
            {
            TBTPowerStateValue pwr = EBTPowerOff;
            (void) Server()->GetHwPowerState( pwr );
            if( pwr )
                {
                // Simply forward it to the pairing manager
                Server()->PairManager().ProcessCommandL( aMessage );
                if ( opcode == EBTEngPairDevice )
                    {
                    iPairMessage = RMessage2( aMessage );
                    }
                }
            else
                {
                User::Leave( KErrNotReady );
                }
            break;
            }
        case EBTEngCancelPairDevice:
            {
            CancelPairRequest();
            break;
            }
        default:
            {
            TRACE_INFO( ( _L( "[BTENG]\t DispatchMessageL: bad request (%d)" ), 
                                aMessage.Function() ) )
            User::Leave( KErrArgument );
            }
            break;
        }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Only the originator of pairing can cancel the pairing request.
// ---------------------------------------------------------------------------
//
void CBTEngSrvSession::CancelPairRequest()
    {
    if ( !iPairMessage.IsNull() )
        {
        Server()->PairManager().CancelCommand( iPairMessage.Function() );
        iPairMessage.Complete( KErrCancel );
        }
    }