/*

* ============================================================================

*  Name        : btnotifconnection.cpp

*  Part of     : bluetoothengine / btnotif

*  Description : Class for observing events of a single connection, and for 

*                managing any user notifications related to the connection.

*

*  Copyright © 2009 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:

*  Nokia Corporation

* ============================================================================

* Template version: 4.1

*/

#include "btnotifconnection.h"

#include <btextnotifiers.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <btextnotifierspartner.h>

#endif

#include "btnotifconnectiontracker.h"

#include "btnotifpairinghelper.h"

#include "btnotificationmanager.h"

#include "btnotifclientserver.h"

#include "bluetoothtrace.h"

/**  Id for the baseband connection watcher active object. */

const TInt KConnectionWatcher = 40;

/**  Id for the registry watcher active object. */

const TInt KRegistryWatcher = 41;

/**  Id for the active object for updating the registry. */

const TInt KRegistryRetriever = 42;

/**  Event mask for subscribing to baseband connection events  

 * (need to check if these are appropriate). */

const TInt KBbEventMask = ENotifyAnyRole | ENotifyAuthenticationComplete |

    ENotifyPhysicalLinkUp | ENotifyPhysicalLinkDown | ENotifyPhysicalLinkError;

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

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

// Decide the device name to display from the device information, and 

// converts the name if necessary.

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

//

void GetDeviceNameL( TBTDeviceName& aName, const CBTDevice& aDevice )

    {

    if( aDevice.IsValidFriendlyName() )

        {

        aName.Copy( aDevice.FriendlyName() );

        }

    else

        {

        aName.Zero();

        if( aDevice.IsValidDeviceName() )

            {

            aName = BTDeviceNameConverter::ToUnicodeL( aDevice.DeviceName() );

            }

        }

    }

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

// Compare 2 device records device pairing has succeeded.

// aDev2 is the updated device record, aDev1 is the previous record.

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

//

TBool CheckRegistryPairedStatus( const CBTDevice* aOrig, const CBTDevice* aNew )

    {

    TBool result = EFalse;

    // Use the device class to check that this has any valid information.

    if( aOrig->AsNamelessDevice().IsValidDeviceClass() &&

        !( aOrig->IsValidPaired() && aOrig->IsPaired() ) ||

        aOrig->LinkKeyType() == ELinkKeyUnauthenticatedUpgradable )

        {

        // Only consider the result if the original device is not marked as paired.

        if( aNew->IsValidPaired() && aNew->IsPaired() && aNew->IsValidLinkKey() && 

            aNew->LinkKeyType() != ELinkKeyUnauthenticatedUpgradable )

            {

            // The new device record has valid pairing information, so

            // this device is now paired.

            result = ETrue;

            }

        }

    return result;

    }

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

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

// C++ default constructor

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

//

CBTNotifConnection::CBTNotifConnection(  const TBTDevAddr& aAddr,

    CBTNotifConnectionTracker* aTracker )

:   iAddr( aAddr ),

    iTracker( aTracker )

    {

    }

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

// Symbian 2nd-phase constructor

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

//

void CBTNotifConnection::ConstructL()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    iDevice = CBTDevice::NewL( iAddr );

    iPhyActive = CBtSimpleActive::NewL(*this, KConnectionWatcher );

    iRegActive = CBtSimpleActive::NewL( *this, KRegistryRetriever );

    // ToDo: need to check if this succeeds if a connection is 

    // being created, in case of outgoing pairing.

    User::LeaveIfError( iPhyLink.Open( iTracker->SocketServerSession(), iAddr ) );

    // Subscribe to events.

    iBasebandEvent.FillZ(); // To be sure that we are not reading false events.

    iPhyLink.NotifyNextBasebandChangeEvent( iBasebandEvent,

                iPhyActive->RequestStatus(), KBbEventMask );

    iPhyActive->GoActive();

    // Get the details from BT registry

    TBTRegistrySearch pattern;

    pattern.FindAddress( iAddr );

    User::LeaveIfError( iRegistry.Open( iTracker->RegistryServerSession() ) );

    iRegistry.CreateView( pattern, iRegActive->RequestStatus() );

    iRegActive->GoActive();

    iCurrentOp = EReadingRegistry;

    iRegDevArray  = new CBTDeviceArray(1);  // only 1 entry ever used

    // ToDo: more initialization needed?

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// NewLC.

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

//

CBTNotifConnection* CBTNotifConnection::NewLC( const TBTDevAddr& aAddr,

    CBTNotifConnectionTracker* aTracker )

    {

    CBTNotifConnection* self = new( ELeave ) CBTNotifConnection( aAddr, aTracker );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CBTNotifConnection::~CBTNotifConnection()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if( iNotification )

        {

        // Clear the notification callback, we cannot receive them anymore.

        iNotification->RemoveObserver();

        iNotification->Close(); // Also dequeues the notification from the queue.

        iNotification = NULL;

        }

    delete iRegActive;

    delete iRegistryResponse;

    iRegistry.Close();

    delete iDevMan;

    delete iPhyActive;

    iPhyLink.Close();

    delete iDevice;

    delete iPairingHelper;

    while( iMsgHandleQ.Count() )

        {

        CompleteClientRequest( KErrDisconnected, KNullDesC8 );

        }

    iMsgHandleQ.Close();

    iAcceptedConnections.Close();

    iDeniedConnections.Close();

    iRegDevArray->ResetAndDestroy(); 

    delete iRegDevArray;

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Check what to do next.

// This function should be called whenever we may be ready for the next

// request/action, which is from any callback function i.e. 

// MBAORequestCompletedL, MBRNotificationClosed, HandleNotifierRequestL and

// CancelNotifierRequestL.

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

//

void CBTNotifConnection::CheckNextOperationL()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if( iCurrentOp == EIdle )

        {

        // Check the link state, to see if it has gone down already.

        TUint32 linkState = 0;

        TInt err = iPhyLink.PhysicalLinkState( linkState );

        TBool linkDown = linkState & ENotifyPhysicalLinkDown;

        if( ( !err && linkDown ) || err == KErrDisconnected )

            {

            // The link state tells us that the link is down,

            // inform the connection tracker the we are done.

            iTracker->HandleLinkCountChangeL();

            // Note that we may be deleted now!

            }

        else if( iMsgHandleQ.Count() )

            {

            // Get the next request and handle it.

            // ToDo: differentiate between notifier and pairing message!

            const RMessage2* message = iTracker->Server()->FindMessageFromHandle( iMsgHandleQ[0] );

            NOTIF_NOTHANDLED( message )

            TInt opcode = message->Function();

            if( opcode <= EBTNotifUpdateNotifier )

                {

                TBuf8<0x250> paramsBuf;    // Size needs to be long enough to read all possible parameter sizes.

                message->ReadL( EBTNotifSrvParamSlot, paramsBuf );

                HandleNotifierRequestL( paramsBuf, *message );

                }

            else

                {

                iMsgHandleQ.Remove( 0 );

                StartBondingL( *message );

                }

            }

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Complete the first outstanding client request and removes it from the queue.

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

//

void CBTNotifConnection::CompleteClientRequest( TInt aReason, const TDesC8& aReply )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    NOTIF_NOTHANDLED( iMsgHandleQ.Count() )

    TInt err = iTracker->Server()->CompleteMessage( iMsgHandleQ[0], aReason, aReply );

    NOTIF_NOTHANDLED( !err )

    iMsgHandleQ.Remove( 0 );

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Distinguish a request and pass to corresponding handle.

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

//

void CBTNotifConnection::HandleNotifierRequestL( const TDesC8& aParams,

    const RMessage2& aMessage )

    {

    BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aMessage.Int0() );

    if( !iMsgHandleQ.Count() || iMsgHandleQ[0] != aMessage.Handle() )

        {

        // If we are processing a queued request, we of course don't queue 

        // it again. In that case we are handling the first request from the queue.

        iMsgHandleQ.AppendL( aMessage.Handle() );

        }

    if( iCurrentOp == EIdle || iCurrentOp == EBonding )

        {

        // ToDo: check non-pairing operation when bonding

        TInt uid = aMessage.Int0();

        if( uid == KBTManAuthNotifierUid.iUid )

            {

            HandleAuthorizationReqL( aParams );

            }

        else if( uid == KBTManPinNotifierUid.iUid ||

                 uid == KBTPinCodeEntryNotifierUid.iUid ||

                 uid == KBTNumericComparisonNotifierUid.iUid ||

                 uid == KBTPasskeyDisplayNotifierUid.iUid )

            {

            if( !iPairingHelper )

                {

                BOstrace0( TRACE_NORMAL, DUMMY_DEVLIST, 

                        "[BTNOTIF]\t CBTNotifConnection::HandleNotifierRequestL: creating CBTNotifPairingHelper");

                iPairingHelper = CBTNotifPairingHelper::NewL( this, iTracker );

                }

            if( iCurrentOp != EBonding  )

                {

                iCurrentOp = EPairing;

                }

            iPairingHelper->StartPairingNotifierL( uid, aParams );

            }

        // We may be done with the current request, proceed to the next one

        CheckNextOperationL();

        }

    BOstraceFunctionExit1( DUMMY_DEVLIST, this );

    }

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

// Update a notifier, update the outstanding dialog if the notifier request 

// is currently being served.

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

//

void CBTNotifConnection::HandleNotifierUpdateL( const TDesC8& aParams,

    const RMessage2& aMessage )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    NOTIF_NOTHANDLED( iCurrentOp != EIdle )

    (void) aParams;

    TBuf8<0x250> paramsBuf;    // Size needs to be long enough to read all possible sizes.

    aMessage.ReadL( EBTNotifSrvParamSlot, paramsBuf );

    TInt uid = aMessage.Int0();

    if( uid == KBTManAuthNotifierUid.iUid )

        {

        TBTNotifierUpdateParams params;

        TPckgC<TBTNotifierUpdateParams> paramsPckg( params );

        paramsPckg.Set( paramsBuf );

        // The result means result of conversion to unicode

        if( !paramsPckg().iResult )

            {

            // Only update locally, registry will update us with the same info later on.

            iDevice->SetDeviceNameL( BTDeviceNameConverter::ToUTF8L( paramsPckg().iName ) );

            if( iNotification )

                {

                // Update the dialog with the new name. It is up to the dialog to 

                // determine the validity (in case another dialog is shown).

                //iNotification->Update(  )

                }

            }

        }

    else if( iPairingHelper && ( uid == KBTPinCodeEntryNotifierUid.iUid ||

             uid == KBTNumericComparisonNotifierUid.iUid ||

             uid == KBTPasskeyDisplayNotifierUid.iUid ) )

        {

        // Just forward to pairing helper

        iPairingHelper->UpdatePairingNotifierL( uid, paramsBuf );

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Cancel a request, dismiss the outstanding dialog if the notifier request 

// is currently being served.

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

//

void CBTNotifConnection::CancelNotifierRequestL( const RMessage2& aMessage )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    NOTIF_NOTHANDLED( iCurrentOp != EIdle )

    TInt pos = iMsgHandleQ.Find( aMessage.Handle() );

    if( pos > KErrNotFound )

        {

        // We have queued the message, remove it from the queue.

        iMsgHandleQ.Remove( pos );

        // We use the supplied handle to remove it, as it may not be

        // the first in the queue.

        TInt err = iTracker->Server()->CompleteMessage( aMessage.Handle(), KErrCancel, KNullDesC8 );

        NOTIF_NOTHANDLED( !err )

        if( pos == 0 )

            {

            // There could be the case that we are still post-processing

            // the previous request (e.g. blocking query), then the next

            // notification is not yet started but the first in the queue.

            // We can see that from the current operation type.

            if( iNotification && iCurrentOp < EAdditionalNotes )

                {

                // Cancel the user query

                // This will also unregister us from the notification.

                TInt err = iNotification->Close();

                NOTIF_NOTHANDLED( !err )

                iNotification = NULL;

                iCurrentOp = EIdle;

                }

            if( iPairingHelper )

                {

                // The pairing helper calls back PairingCompleted and sets state.

                iPairingHelper->CancelPairingNotifierL( aMessage.Int0() );

                // The pairing helper may have now been deleted.

                }

            }

        }

    // We may be done with the current request, proceed to the next one

    CheckNextOperationL();

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Start a bonding operation with the remote device.

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

//

void CBTNotifConnection::StartBondingL( const RMessage2& aMessage )

    {

    BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aMessage.Function() );

    if( iCurrentOp == EIdle || iCurrentOp > EInternalOperations )

        {

        __ASSERT_ALWAYS( !iPairingHelper, PanicServer( EBTNotifPanicBadState ) );

        iPairingHelper = CBTNotifPairingHelper::NewL( this, iTracker );

        // The pairingg helper stored the handle, not in our queue here.

        // This is because bonding will generate a pairing notifier request, which 

        // will be completed first. The bookkeeping gets complicated if we have to

        // re-order the queue here.

        iPairingHelper->StartBondingL( aMessage.Handle() );

        iCurrentOp = EBonding;

        }

    else if( iCurrentOp == EPairing || iCurrentOp == EBonding )

        {

        // We only do one pairing at the time.

        User::Leave( KErrInUse );

        }

    else

        {

        // We only store it here if it is not handled immediately.

        iMsgHandleQ.AppendL( aMessage.Handle() );

        }

    BOstraceFunctionExit1( DUMMY_DEVLIST, this );

    }

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

// Cancel an ongoing bonding operation with the remote device.

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

//

void CBTNotifConnection::CancelBondingL()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if( iPairingHelper )

        {

        iPairingHelper->CancelBondingL();

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// The pairing handler has completed a pairing operation.

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

//

void CBTNotifConnection::PairingCompleted()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    __ASSERT_ALWAYS( iPairingHelper, PanicServer( EBTNotifPanicNullMember ) );

    if( iPairingHelper->CurrentOperation() == CBTNotifPairingHelper::EIdle )

        {

        // We are still idle. Remove the pairing helper

        delete iPairingHelper;

        iPairingHelper = NULL;

        }

    if( iCurrentOp == EPairing || iCurrentOp == EBonding )

        {

        iCurrentOp = EIdle;

        TRAP_IGNORE( CheckNextOperationL() );

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Process a new pairing result, and determine if we need to show 

// anything to the user.

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

//

void CBTNotifConnection::PairingResult( TInt aError )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if( !iPairingHelper )

        {

        TRAP_IGNORE( iPairingHelper = CBTNotifPairingHelper::NewL( this, iTracker ) );

        }

    if( iPairingHelper )

        {

        iPairingHelper->HandleAuthenticationCompleteL( aError );

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Process the new service-level connection, and determine if we need to

// show anything to the user.

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

//

void CBTNotifConnection::ServiceConnectedL( TBTProfile aProfile )

    {

    (void) aProfile;

    }

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

// Process the new service-level disconnection, and determine if we need to

// show anything to the user.

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

//

void CBTNotifConnection::ServiceDisconnectedL( TBTProfile aProfile )

    {

    (void) aProfile;

    }

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

// Ask the user if he/she wants to block future connection requests. 

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

//

void CBTNotifConnection::LaunchBlockingQueryL()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    iCurrentOp = EBlocking;

    TBTDialogResourceId resourceId = EBlockUnpairedDevice;

    if( iDevice->IsValidPaired() && iDevice->IsPaired() &&

        iDevice->LinkKeyType() != ELinkKeyUnauthenticatedUpgradable )

        {

        resourceId = EBlockPairedDevice;

        }

    PrepareNotificationL( TBluetoothDialogParams::EQuery, resourceId );

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Modify the record for the remote device in BTRegistry, with the changes 

// already made in the local record.

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

//