/*

* 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:  Pairing result receiver in Bluetooth engine subsystem

*

*/

#include "btengpairman.h"

#include "btengserver.h"

#include "btengsrvsession.h"

#include "btengotgpair.h"

#include "btengincpair.h"

#include "btengclientserver.h"

#include "debug.h"

#include <e32property.h>

/**  Identification for active object */

enum TPairManActiveRequestId

    {

    ESimplePairingResult,

    EAuthenticationResult,

    ERegistryInitiatePairedDevicesView,

    ERegistryPairedDevicesNewView,

    ERegistryInitiatePairedDevicesList,

    ERegistryGetPairedDevices,

    };

/**  The message argument which holds the Bluetooth address. */

const TInt KBTEngAddrSlot = 0;

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

// Tells if two TBTNamelessDevice instances are for the same remote device

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

//

TBool CompareDeviceByAddress( const TBTNamelessDevice& aDevA, const TBTNamelessDevice& aDevB )

    {

    return aDevA.Address() == aDevB.Address();

    }

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

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

// C++ default constructor

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

//

CBTEngPairMan::CBTEngPairMan( CBTEngServer& aServer )

    : iServer( aServer )

    {

    }

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

// Symbian 2nd-phase constructor

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

//

void CBTEngPairMan::ConstructL()

    {

    TRACE_FUNC_ENTRY

        // Connect to pairing server for authentication & simple pairing 

        // results directly from the BT stack.

        // Pairing server doesn't exist if we run BT 2.0 stack:

    iPairingServ = new (ELeave) RBluetoothPairingServer;

    TInt err = iPairingServ->Connect();

    if ( err)

        {

        delete iPairingServ;

        iPairingServ = NULL;

        }

    else

        {

        User::LeaveIfError( iPairingResult.Open( *iPairingServ ) );

        User::LeaveIfError( iAuthenResult.Open( *iPairingServ ) );

        iSSPResultActive = CBTEngActive::NewL( *this, ESimplePairingResult, CActive::EPriorityStandard );

        iAuthenResultActive = CBTEngActive::NewL( *this, EAuthenticationResult, CActive::EPriorityStandard );        

        }

    // connect to registry

    User::LeaveIfError( iBTRegistry.Open( BTRegServ() ) );    

    iRegistryActive = CBTEngActive::NewL( *this, ERegistryInitiatePairedDevicesView, CActive::EPriorityStandard );

    TRACE_FUNC_EXIT

    }

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

// NewL

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

//

CBTEngPairMan* CBTEngPairMan::NewL( CBTEngServer& aServer )

    {

    CBTEngPairMan* self = NULL;

    self = new  CBTEngPairMan( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CBTEngPairMan::~CBTEngPairMan()

    {

    TRACE_FUNC_ENTRY

    CancelSubscribe();

    delete iSSPResultActive;

    delete iAuthenResultActive;

    delete iRegistryActive;

    delete iPairedDevicesResp;

    delete iPairer;

    if ( iPairedDevices )

        {

        iPairedDevices->Close();

        delete iPairedDevices;

        }

    iBTRegistry.Close();

    iPairingResult.Close();

    iAuthenResult.Close();

    if ( iPairingServ )

        {

        iPairingServ->Close();

        delete iPairingServ;

        }

    if ( !iMessage.IsNull() )

        {

        iMessage.Complete( KErrCancel );

        }

    TRACE_FUNC_EXIT

    }

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

// Handles pairing related commands from BTEng clients.

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

//

void CBTEngPairMan::ProcessCommandL( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    TInt opcode = aMessage.Function();

    TBTDevAddrPckgBuf addrPkg;

    switch( opcode )

        {

        case EBTEngSetPairingObserver:

            {

            aMessage.ReadL( KBTEngAddrSlot, addrPkg );

            SetPairObserver( addrPkg(), aMessage.Int1() );

            break;

            }

        case EBTEngPairDevice:

            {

            if ( !iMessage.IsNull() )

                {

                User::Leave( KErrServerBusy );

                }

            TBTDevAddrPckgBuf addrPkg;

            aMessage.ReadL( KBTEngAddrSlot, addrPkg );

            PairDeviceL( addrPkg(), aMessage.Int1() );

            iMessage = RMessage2( aMessage );

            break;

            }

        case EBTEngCancelPairDevice:

            {

            // Only the client who requested pairing can cancel it:

            if ( !iMessage.IsNull() && aMessage.Session() == iMessage.Session() )

                {

                iPairer->CancelOutgoingPair();

                iMessage.Complete( KErrCancel );

                }

            break;

            }

        default:

            {

            TRACE_INFO( ( _L( "CBTEngPairMan ProcessCommandL: bad request (%d)" ), 

                           aMessage.Function() ) )

            User::Leave( KErrArgument );

            }

        }

    TRACE_FUNC_EXIT    

    }

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

// Handle a change in BTRegistry remote devices table.

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

//

void CBTEngPairMan::RemoteRegistryChangeDetected()

    {

    if ( !iRegistryActive->IsActive() )

        {

        CreatePairedDevicesView( ERegistryPairedDevicesNewView );

        }

    else

        {

        iNotHandledRegEventCounter++;

        }

    }

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

// Returns the RBluetoothPairingServer instance.

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

//

RBluetoothPairingServer* CBTEngPairMan::PairingServer()

    {

    return iPairingServ;

    }

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

// Access the reference of RSockServ

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

//

RSocketServ& CBTEngPairMan::SocketServ()

    {

    return iServer.SocketServer();

    }

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

// Access the reference of RBTRegSrv

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

//

RBTRegServ& CBTEngPairMan::BTRegServ()

    {

    return iServer.RegistrServer();

    }

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

// Deletes the current pairing handler and transfer the responsibility

// to the specified.

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

//

void CBTEngPairMan::RenewPairer( CBTEngPairBase* aPairer )

    {

    delete iPairer;

    iPairer = aPairer;

    }

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

// Find the session who requested this and completes its request.

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

//

void CBTEngPairMan::OutgoingPairCompleted( TInt aErr )

    {

    TRACE_FUNC_ENTRY

    // the meaning of KHCIErrorBase equals KErrNone. Hide this specific BT stack

	// detail from clients:

    if ( aErr == KHCIErrorBase )

        {

        aErr = KErrNone;

        }

    // we must complete client's pairing request:

    if ( !iMessage.IsNull()  )

        {

        iMessage.Complete( aErr );

        }

    TRACE_FUNC_EXIT

    }

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

// A session will be ended, completes the pending request for this session.

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

//

void CBTEngPairMan::SessionClosed( CSession2* aSession )

    {

    TRACE_FUNC_ARG( ( _L( " session %x"), aSession ) )

    if ( !iMessage.IsNull() && iMessage.Session() == aSession )

        {

        iMessage.Complete( KErrCancel );

        }

    TRACE_FUNC_EXIT

    }

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

// Unpair the device from registry

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

//

void CBTEngPairMan::UnpairDevice( const TBTDevAddr& aAddr )

    {

    TRACE_FUNC_ENTRY

    TIdentityRelation<TBTNamelessDevice> addrComp( CompareDeviceByAddress );

    TBTNamelessDevice dev;

    dev.SetAddress( aAddr );

    // only do unpairing if the we have a link key with it.

    TInt index = iPairedDevices->Find( dev, addrComp );

    if ( index > KErrNotFound )

        {

        dev = (*iPairedDevices)[index];

            {

            }

        }

    TRACE_FUNC_EXIT

    }

TInt CBTEngPairMan::AddUiCookieJustWorksPaired( const TBTNamelessDevice& aDev )

    {

    TInt err( KErrNone );

    // There might be UI cookies used by other applications,

    // we should not overwrite them. 

    TInt32 cookie = aDev.IsValidUiCookie() ? aDev.UiCookie() : EBTUiCookieUndefined;

    if ( !( cookie & EBTUiCookieJustWorksPaired ) )

        {

        // Only update the cookie if the wanted one is not in registry yet

        // to keep minimal operations with registry.

        TBTNamelessDevice dev = aDev;		

        cookie |= EBTUiCookieJustWorksPaired;

        dev.SetUiCookie( cookie );

        err = UpdateRegDevice( dev );

        TRACE_INFO( ( _L( "[BTENG] CBTEngOtgPair write Ui cookie ret %d"), err ) );

        }

    return err;

    }

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

// update a nameless device in registry

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

//

TInt CBTEngPairMan::UpdateRegDevice( const TBTNamelessDevice& aDev )

    {

    TRequestStatus status( KRequestPending );

    // update the device in registry synchronously

    iBTRegistry.ModifyDevice( aDev, status );

    User::WaitForRequest( status );

    TRACE_INFO( ( _L( "UpdateRegDevice, ret %d"), status.Int() ) )

    return status.Int();

    }

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

// Ask server class the connection status of the specified device

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

//

TBTEngConnectionStatus CBTEngPairMan::IsDeviceConnected( const TBTDevAddr& aAddr )

    {

    return iServer.IsDeviceConnected( aAddr );

    }

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

// From class MBTEngActiveObserver.

// Checks if there is an authentication result.

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

//

void CBTEngPairMan::RequestCompletedL( CBTEngActive* /*aActive*/, TInt aId, TInt aStatus )

    {

    TRACE_FUNC_ARG( ( _L( "aId: %d, aStatus: %d"), aId, aStatus ) )

        // Check which request completed.

    switch( aId )

        {

        case ESimplePairingResult:

            {

            TBTDevAddr tmpAddr = iSimplePairingRemote;

            if (aStatus != KErrServerTerminated)

                {

                SubscribeSspPairingResult();

                }

            HandlePairingResultL( tmpAddr, aStatus );

            break;

            }

        case EAuthenticationResult:

            {

            TBTDevAddr tmpAddr = iAuthenticateRemote;

            if (aStatus != KErrServerTerminated)

                {

                SubscribeAuthenticateResult();

                }

            HandlePairingResultL( tmpAddr, aStatus );

            break;

            }

        case ERegistryInitiatePairedDevicesView:

        case ERegistryPairedDevicesNewView:

            {

            HandleCreatePairedDevicesViewCompletedL( aStatus, aId );

            break;

            }

        case ERegistryInitiatePairedDevicesList:

        case ERegistryGetPairedDevices:    

            {

            HandleGetPairedDevicesCompletedL( aStatus, aId );

            break;

            }

        default:

                // Should not be possible, but no need for handling.

            TRACE_INFO( (_L("[BTEng]: CBTEngPairMan::RequestCompletedL unhandled event!!") ) )