/*

* Copyright (c) 2010 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: 

*

*/

#include "btnotifincomingpairinghandler.h"

#include "btnotifsecuritymanager.h"

#include "btnotifoutgoingpairinghandler.h"

#include <btengconstants.h>

#include "bluetoothtrace.h"

const TInt KBTNotifWaitingForPairingOkDelay = 500000; // 0.5s

const TInt KBTNotif10SecondTimer = 10000000;

enum TPairingStageId

    {

    /**

     * is monitoring physical link status

     */

    EPhysicalLinkNotify = 100,

    EWaitingForPairingOk,

    };

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

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

// C++ default constructor

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

//

CBTNotifIncomingPairingHandler::CBTNotifIncomingPairingHandler( CBTNotifSecurityManager& aParent, 

    const TBTDevAddr& aAddr) : CBTNotifBasePairingHandler( aParent, aAddr )

    {

    }

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

// 2nd phase constructor

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

//

void CBTNotifIncomingPairingHandler::ConstructL()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    BaseConstructL();

    iActivePairingOk = CBtSimpleActive::NewL(*this, EWaitingForPairingOk );

    User::LeaveIfError( iPairingOkTimer.CreateLocal() );

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// NewL

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

//

CBTNotifBasePairingHandler* CBTNotifIncomingPairingHandler::NewL( CBTNotifSecurityManager& aParent, 

    const TBTDevAddr& aAddr)

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    CBTNotifIncomingPairingHandler* self = new (ELeave) CBTNotifIncomingPairingHandler(aParent, aAddr);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    return self;

    }

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

// Destructor

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

//

CBTNotifIncomingPairingHandler::~CBTNotifIncomingPairingHandler()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    // Cancel all outstanding requests

    CancelPlaNotification();

    iPla.Close();

    delete iActivePairingOk;

    iPairingOkTimer.Close();

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Accept this message only if the specified device is the same as this is

// dealing with.

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

//

TInt CBTNotifIncomingPairingHandler::ObserveIncomingPair( const TBTDevAddr& aAddr )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    TInt err( KErrServerBusy );

    if ( iAddr == aAddr )

        {

        err = KErrNone;

        // This function is called by a notifier, which means the UI has been involved

        // Therefore we can display it in the paired devices list

        iUserAwarePairing = ETrue; 

         if ( !iActive->IsActive() && !OpenPhysicalLinkAdaptor() )

            {

            // If we are observing physical link, or showing user a note,

            // we won't interrupt it.

            UnSetPairResult();

            MonitorPhysicalLink();

            }

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    return err;

    }

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

// Assign the responsibility of outgoing pair handling to CBTEngOtgPair

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

//

void CBTNotifIncomingPairingHandler::HandleOutgoingPairL( const TBTDevAddr& aAddr, TUint aCod )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    // Outgoing pairing always takes highest priority:

    CBTNotifBasePairingHandler* pairinghandler = CBTNotifOutgoingPairingHandler::NewL( iParent, aAddr );

    pairinghandler->HandleOutgoingPairL( aAddr, aCod );

    iParent.RenewPairingHandler( pairinghandler );

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Accept this message only if the specified device is the same as this is

// dealing with.

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

//

void CBTNotifIncomingPairingHandler::StopPairHandling( const TBTDevAddr& aAddr )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if ( aAddr == iAddr )

        {

        iParent.RenewPairingHandler( NULL );

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Notify user if pairing failed.

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

//

void CBTNotifIncomingPairingHandler::DoHandlePairServerResult( TInt aResult )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    CancelPlaNotification();

    // For a successful pairing, we need wait for registry table change.

    if( aResult != KErrNone && aResult != KHCIErrorBase )

        {

        // Pair failure situation.

        SetPairResult( aResult );

        TRAPD(err , ShowPairingResultNoteL(KErrGeneral));

        if(!err && iNotification)

            {

            iNotification->SetCloseTimer(KBTNotif10SecondTimer);

            }

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Kill this if the linkkey type indicates OBEX authentication.

// Otherwise notify user the pair result.

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

//

void CBTNotifIncomingPairingHandler::DoHandleRegistryNewPairedEvent( const TBTNamelessDevice& aDev )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    // First of all cancel the iPairingOkTimer timer, if active

    if (iActivePairingOk->IsActive())

        {

        iActivePairingOk->Cancel();

        UnSetPairResult();  // we might have set it before (if the link went down) so we want to reset it.   

        }

    // If the user checked the trusted checkbox then we trust the device

    if(iTrustDevice)

        {

        iParent.TrustDevice(iAddr);

        }

    if (aDev.LinkKeyType() == ELinkKeyUnauthenticatedNonUpgradable && !iUserAwarePairing)

		{

		// If an application uses btengconnman API to connect a service of 

		// this device and JW pairing occurred as part of security enforcement,

		// it shall be a user aware pairing, and we shall add this device in paired

		// view. In this way, user is able to disconnect the device from our UI.

		// Otherwise the link key has been created by a device without IO requesting 

		// a service connection with phone. We won't take any action (e.g. remove 

		// link key) in this case. As the result, this device can't be seen in our UI, 

		// however other applications are still freely to use its services.

		TBTEngConnectionStatus status = iParent.ConnectStatus( aDev.Address() );

		if ( status == EBTEngConnecting || status == EBTEngConnected )

			{

			// the return error is ingore as we can not have other proper 

			// exception handling option:

			(void) iParent.AddUiCookieJustWorksPaired( aDev );

			}

		TRAP_IGNORE(ShowPairingResultNoteL(KErrNone));

		iParent.RenewPairingHandler( NULL );

		}

    else if (aDev.LinkKeyType() == ELinkKeyUnauthenticatedUpgradable && !iUserAwarePairing)

		{

		// The linkkey has been created  by an incoming OBEX service request

		// which resulted a pairing event received from pair server.

		iParent.RenewPairingHandler( NULL );

		}

    else

		{

		if (aDev.LinkKeyType() == ELinkKeyUnauthenticatedNonUpgradable || aDev.LinkKeyType() == ELinkKeyUnauthenticatedUpgradable)

			{

			// The user was involved in the pairing, so display in the paired devices list

			(void) iParent.AddUiCookieJustWorksPaired(aDev);

			}

		// Other pairing model than Just Works:

		CancelPlaNotification();

		SetPairResult( KErrNone );

		TRAP_IGNORE(ShowPairingResultNoteL(KErrNone));

		iParent.RenewPairingHandler( NULL );

		}

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// From class MBTNotifPairingAOObserver.

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

//

void CBTNotifIncomingPairingHandler::RequestCompletedL( CBtSimpleActive* aActive, TInt aStatus )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    // Check which request completed.

    switch( aActive->RequestId() )

        {

        case EPhysicalLinkNotify:

            {

            // Check if the link has disconnected.

            HandlePhysicalLinkResultL( aStatus );

            break;

            }

        case EWaitingForPairingOk:

            {

            // pairing failed, inform user:

            if (iPairResult == KErrNone)

                {

                // iPairResult must have been set as an error. if it's not it means somewhere else

                // it has been reset. But we need to have it set to an error as we are notifying 

                // the "unable to pair" message.

                SetPairResult(KErrGeneral);

                TRAPD(err , ShowPairingResultNoteL(KErrGeneral));

                if(!err && iNotification)

                    {

                    iNotification->SetCloseTimer(KBTNotif10SecondTimer);

                    }

                }

            iParent.RenewPairingHandler( NULL );

            break;

            } 

        default:

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

            break;

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// From class MBTNotifPairingAOObserver.

// cancels an outstanding request according to the given id.

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

//

void CBTNotifIncomingPairingHandler::CancelRequest( TInt aRequestId )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    switch ( aRequestId ) 

        {

        case EPhysicalLinkNotify:

            {

            iPla.CancelNextBasebandChangeEventNotifier();

            break;

            }

        case EWaitingForPairingOk:

            {

            iPairingOkTimer.Cancel();

            break;

            }

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// From class MBTNotifPairingAOObserver.

// Handles a leave in RequestCompleted by simply self-destructing.

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

//

void CBTNotifIncomingPairingHandler::HandleError( CBtSimpleActive* aActive, TInt aError )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    (void) aActive;

    (void) aError;

    // Our error handling is to just stop observing. 

    // Nothing critical to be preserved here, the user 

    // just won't get any notification of pairing result.

    iParent.RenewPairingHandler( NULL );

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Subscribe to physical link notifications. 

// physical link must exist when calling this function.

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

//

void CBTNotifIncomingPairingHandler::MonitorPhysicalLink()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    iActive->SetRequestId( EPhysicalLinkNotify );

    // Subscribe to disconnect and error events.

    iPla.NotifyNextBasebandChangeEvent( iBbEvent, 

                            iActive->RequestStatus(), 

                            ENotifyPhysicalLinkDown | ENotifyPhysicalLinkError );

    iActive->GoActive();

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Opens the adaptor if physical link exists.

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

//

TInt CBTNotifIncomingPairingHandler::OpenPhysicalLinkAdaptor()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    TInt err ( KErrNone );

    if( !iPla.IsOpen() )

        {

        // Try to open the adapter in case it failed earlier.

        // This can happen for outgoing dedicated bonding with 

        // non-SSP device, as the PIN dialog can be kept open even 

        // though the link has dropped because of a time-out.

        err = iPla.Open( iParent.SocketServ(), iAddr );

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    return err;

    }

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

// Cancel outstanding physical link notification

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

//

void CBTNotifIncomingPairingHandler::CancelPlaNotification()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if( iActive && iActive->RequestId() == EPhysicalLinkNotify )

        {

        // cancel Baseband monitor

        iActive->Cancel();

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Handle a physical link event. Notify pair failed if physical link is down.

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

//

void CBTNotifIncomingPairingHandler::HandlePhysicalLinkResultL( TInt aResult )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    // Check if the connection is still alive.

    TBool physicalLinkDown = 

        ( iBbEvent().EventType() == ENotifyPhysicalLinkDown | ENotifyPhysicalLinkError );

    if( aResult || physicalLinkDown )

        {

        // link went down. It might be because of pairing failed or the remote device disconnected the

        // physical link after a successful pairing.

        // we wait for 0.5 secs before notifying the "unable to pair" message as, if the pair is 

        // successful, we manage it to show the right confirmation message.

        SetPairResult( (aResult == 0) ? KErrGeneral : aResult );

        iPairingOkTimer.After(iActivePairingOk->iStatus, KBTNotifWaitingForPairingOkDelay);

        iActivePairingOk->GoActive();

        }

    else

        {

        // Uninteresting event, re-subscribe.

        MonitorPhysicalLink();

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }