/*

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

*  Name        : btnotifpairinghelper.cpp

*  Part of     : bluetoothengine / btnotif

*  Description : Helper class for processing pairing requests and results, as extended functionality for CBTNotifConnection.

*

*  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 "btnotifpairinghelper.h"

#include <bt_sock.h>

#include <btextnotifiers.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <btextnotifierspartner.h>

#endif

#include "btnotifconnection.h"

#include "btnotifconnectiontracker.h"

#include "btnotificationmanager.h"

#include "btnotifserver.h"

#include "bluetoothtrace.h"

/**  Id for the active object for a dedicated bonding session. */

const TInt KDedicatedBonding = 50;

/**  Length of the default PIN. */

const TInt KDefaultPinLength = 4;

/**  Default PIN character. */

const TText8 KDefaultPinValue = '0';

/**  Format syntax for numeric comparison value. */

_LIT( KNumCompFormat, "%06u" );

/**  Format syntax for passkey display value. */

_LIT( KPassKeyFormat, "%06u" );

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

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

// ?description

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

//

/*?type ?function_name( ?arg_type ?arg,

                      ?arg_type ?arg )

    {

    }

*/

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

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

// C++ default constructor.

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

//

CBTNotifPairingHelper::CBTNotifPairingHelper( CBTNotifConnection* aConnection,

    CBTNotifConnectionTracker* aTracker )

:   iConnection( aConnection ),

    iTracker( aTracker )

    {

    }

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

// Symbian 2nd-phase constructor.

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

//

void CBTNotifPairingHelper::ConstructL()

    {

    if( iConnection )

        {

        iDevice = iConnection->BTDevice();

        }

    }

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

// NewL

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

//

CBTNotifPairingHelper* CBTNotifPairingHelper::NewL( CBTNotifConnection* aConnection,

    CBTNotifConnectionTracker* aTracker )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    CBTNotifPairingHelper* self = new( ELeave ) CBTNotifPairingHelper( aConnection, aTracker );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    return self;

    }

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

// Destructor.

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

//

CBTNotifPairingHelper::~CBTNotifPairingHelper()

    {

    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 iParams;

    if( iBondingActive )

        {

        iBondingActive->Cancel();   // Will close subsession;

        }

    delete iBondingActive;

    iBondingSession.Close();

    iBondingSocket.Close();

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Handle the authentication result from the baseband. Show the result in a note.

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

//

void CBTNotifPairingHelper::HandleAuthenticationCompleteL( TInt aError )

    {

    BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aError );

    if( iOperation == EDedicatedBonding || iOperation == EAwaitingPairingResult ||

        iOperation == EAutoPairing )

        {

        // Default case (aError == 0): Success, we are now paired.

        TBTDialogResourceId resourceId = EPairingSuccess;

        TBool autoPairing = ( iOperation == EAutoPairing ); // Remember the autopairing state

        iOperation = EShowPairingSuccess;

        if( aError && aError != KHCIErrorBase )

            {

            // Authentication failure, means pairing failed.

            resourceId = EPairingFailure;

            iOperation = EShowPairingFailure;

            // Communicate the error now that we still remember it.

            if( iDedicatedBonding )

                {

                if( autoPairing && aError == KHCIErrorBase - EAuthenticationFailure )

                    {

                    BOstrace0( TRACE_NORMAL, DUMMY_DEVLIST, 

                            "[BTNOTIF]\t CBTNotifPairingHelper::HandleAuthenticationCompleteL: Autopairing failed, we need to try again.");

                    // Autopairing failed, we need to try again.

                    iOperation = EAutoPairing;  // Reset back

                    resourceId = ENoResource;

                    }

                CompleteBondingL( aError );

                }

            }

        if( resourceId )

            {

            // Inform the user of the result.

            BOstrace0( TRACE_NORMAL, DUMMY_DEVLIST,  

                    "[BTNOTIF]\t CBTNotifPairingHelper::HandleAuthenticationCompleteL: pairing successful, inform user" );

            PrepareNotificationL( TBluetoothDialogParams::EGlobalNotif, resourceId );

            // MBRNotificationClosed will be called from this, which will 

            // check the next stage.

            }

        }

    BOstraceFunctionExit1( DUMMY_DEVLIST, this );

    }

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

// Start a bonding operation with the remote device.

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

//

void CBTNotifPairingHelper::StartBondingL( TInt aHandle )

    {

    BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aHandle );

    __ASSERT_ALWAYS( iOperation == EIdle || iOperation == EDedicatedBonding

                || iOperation == EAutoPairing, PanicServer( EBTNotifPanicBadState ) );

    if( !iBondingActive )

        {

        iBondingActive = CBtSimpleActive::NewL( *this, KDedicatedBonding );

        }

    if( aHandle )

        {

        iDedicatedBonding = aHandle;

        }

    if( iOperation == EIdle )

        {

        iOperation = EDedicatedBonding;

        }

    if( iOperation == EDedicatedBonding && iTracker->PairingServerSession() )

        {

        if( !iBondingActive->IsActive() )

            {

            BtTraceBtAddr1( TRACE_DEBUG,DUMMY_LIST,"CBTNotifPairingHelper::StartBondingL()",iDevice->BDAddr() );

            iBondingSession.Start( *iTracker->PairingServerSession(),

                        iDevice->BDAddr(), iBondingActive->RequestStatus() );

            iBondingActive->GoActive();

            }

        }

    else

        {

        // We are doing autopairing (or the unlikely situation that the pairing server is unavailable)

        CompleteBondingL( KErrServerTerminated );

        }

    BOstraceFunctionExit1( DUMMY_DEVLIST, this);

    }

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

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

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

//

void CBTNotifPairingHelper::CancelBondingL()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if( iDedicatedBonding )

        {

        CompleteBondingL( KErrCancel ); // Closes sessions

        if( iNotification )

            {

            // Cancel the outstanding user query

            // This will also unregister us from the notification.

            TInt err = iNotification->Close();

            NOTIF_NOTHANDLED( !err )

            iNotification = NULL;

            }

        if( iNotifierUid )

            {

            // Also finish up the notifier processing.

            CompletePairingNotifierL( KErrCancel, EFalse, KNullDesC8 );

            }

        iOperation = EIdle;

        iConnection->PairingCompleted();   // This may delete us.

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Handle a notifier request for pairing with the remote device of this connection.

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

//

void CBTNotifPairingHelper::StartPairingNotifierL( TInt aUid, const TDesC8& aParams )

    {

    BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aUid );

    if( iDevice->GlobalSecurity().Banned() && !iDedicatedBonding )

        {

        // ToDo: should this case actually be ignored, and presume that

        // the caller will take care of unblocking the device?

        iOperation = EIdle;

        User::Leave( KErrAccessDenied );

        }

    // Store the parameters locally, we need them later again.

    delete iParams;

    iParams = NULL;

    iParams = HBufC8::NewL( aParams.Length() );

    *iParams = aParams;

    iNotifierUid = aUid;

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

        {

        // The device is still paired, we unpair it first.

        // Deleting the link key will set the device as unpaired.

        iDevice->DeleteLinkKey();

        iOperation = EUnpairing;    // So that parent state does not get changed.

        iConnection->UpdateRegistryEntryL();

        // Note that this will only be done before trying autopairing, so

        // it not interfere with a second attempt;

        }

    // Update the device name

    TBTPasskeyDisplayParams params; // Enough for reading the base class type parameter

    TPckgC<TBTPasskeyDisplayParams> paramsPckg( params );

    paramsPckg.Set( *iParams );

    if( paramsPckg().DeviceName().Length() )

        {

        // The name in the parameter package is the latest one, retrieved from 

        // the remote device during this connection. Update locally.

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

        }

    TBool locallyInitiated = EFalse;

    TBuf<8> numVal;

    TBluetoothDialogParams::TBTDialogType dialog = TBluetoothDialogParams::EInvalidDialog;

    TBTDialogResourceId resource = ENoResource;

    // Read the notifier parameters (sets iOperation as well)

    ParseNotifierReqParamsL( locallyInitiated, numVal, dialog, resource );

    // If this is an incoming pairing, we first ask the user to accept it.

    if( !locallyInitiated && !iDedicatedBonding )

        {

        // Ignore the initatior if we initiated bonding.

        StartAcceptPairingQueryL(); // Overrides iOperation

        }

    else

        {

        __ASSERT_ALWAYS( resource != ENoResource, PanicServer( EBTNotifPanicBadState ) );

        CheckAutoPairingL( locallyInitiated, numVal );

        // CheckAutoPairingL sets 

        if( iOperation != EAutoPairing )

            {

            PrepareNotificationL( dialog, resource );

            if( numVal.Length() )

                {

                TInt err = iNotification->SetData( TBluetoothDeviceDialog::EAdditionalDesc, numVal );

                NOTIF_NOTHANDLED( !err )

                }

            }

        }

    BOstraceFunctionExit1( DUMMY_DEVLIST, this );

    }

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

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

// is currently being served.

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

//

void CBTNotifPairingHelper::UpdatePairingNotifierL( TInt aUid, const TDesC8& aParams )

    {

    (void) aUid;

    TBTNotifierUpdateParams2 params;    // Enough for reading the base class type parameter

    TPckgC<TBTNotifierUpdateParams2> paramsPckg( params );

    paramsPckg.Set( aParams );

    if( paramsPckg().Type() == TBTNotifierUpdateParams2::EPasskeyDisplay )

        {

        // Paskey display update - keypress on remote device.

        }

    else

        {

        // name update

        TBTDeviceNameUpdateParams nameUpdate;

        TPckgC<TBTDeviceNameUpdateParams> nameUpdatePckg( nameUpdate );

        nameUpdatePckg.Set( aParams );

        // The result means result of conversion to unicode

        if( !nameUpdatePckg().Result() )

            {

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

            iDevice->SetDeviceNameL( BTDeviceNameConverter::ToUTF8L( nameUpdatePckg().DeviceName() ) );

            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(  )

                }

            }

        }

    }

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

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

// is currently being served.

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

//

void CBTNotifPairingHelper::CancelPairingNotifierL( TInt aUid )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    // ToDo: we need to check that the UID and the outstanding notification

    // type are matching?

    if( iOperation > EIdle && iOperation < EPostPairingOperations && aUid == iNotifierUid &&

        ( aUid == KBTPinCodeEntryNotifierUid.iUid ||

          aUid == KBTNumericComparisonNotifierUid.iUid ||

          aUid == KBTPasskeyDisplayNotifierUid.iUid ) )

        {

        if( iNotification )

            {

            // Cancel the user query

            // This will also unregister us from the notification.

            TInt err = iNotification->Close();

            NOTIF_NOTHANDLED( !err )

            iNotification = NULL;

            }

        iOperation = EIdle;

        iNotifierUid = 0;

        // We do not call pairing completed from here, our parent will

        // check our status by itself, and may delete us.

        // Any bonding requester needs to be informed though.

        CancelBondingL();

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// 

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

//

void CBTNotifPairingHelper::StartJustWorksProcessingL()

    {

    }

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

// 

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

//

void CBTNotifPairingHelper::CancelJustWorksProcessingL()

    {

    }

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

// From class MBTNotificationResult.

// Handle a result from a user query.

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

//

void CBTNotifPairingHelper::MBRDataReceived( CHbSymbianVariantMap& aData )

    {

    (void) aData;

    NOTIF_NOTIMPL

    }

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

// From class MBTNotificationResult.

// The notification is finished.

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

//

void CBTNotifPairingHelper::MBRNotificationClosed( TInt aError, const TDesC8& aData )

    {

    BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aError );

    // First unregister from the notification, so we can already get the next one.

    iNotification->RemoveObserver();

    iNotification = NULL;

    TRAP_IGNORE( NotificationClosedL( aError, aData ) );

    if( iOperation == EIdle )

        {

        // Any error has been communicated already.

        iConnection->PairingCompleted();   // This may delete us.

        }

    BOstraceFunctionExit1( DUMMY_DEVLIST, this );

    }

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

// From class MBtSimpleActiveObserver.

// Handle the active object completion.

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

//

void CBTNotifPairingHelper::RequestCompletedL( CBtSimpleActive* aActive,

    TInt aStatus )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    switch( aActive->RequestId() )

        {

        case KDedicatedBonding:

            {

            if( iDedicatedBonding )

                {

                // If the result hasn't been processed already.

                HandleAuthenticationCompleteL( aStatus );

                }

            }

            break;

        default:

            NOTIF_NOTIMPL

            break;

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// From class MBtSimpleActiveObserver.

// Cancel and clean up all requests related to the active object.

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

//

void CBTNotifPairingHelper::CancelRequest( TInt aRequestId )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    switch( aRequestId )

        {

        case KDedicatedBonding:

            iBondingSession.Close();

            break;

        default:

            NOTIF_NOTIMPL

            break;

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// From class MBtSimpleActiveObserver.

// 

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

//

void CBTNotifPairingHelper::HandleError( CBtSimpleActive* aActive, 

        TInt aError )

    {

    (void) aActive;

    (void) aError;

    }

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

// Process the user input and complete the outstanding pairing request.

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

//

void CBTNotifPairingHelper::CompletePairingNotifierL( TInt aError, TBool aResult,

    const TDesC8& aData )

    {

    BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aError );

    TInt err = aError;

    TPtrC8 resultData;

    if( !err )

        {

        // The returned data is the entered passkey.

        TBool proceed = iTracker->UpdateBlockingHistoryL( iDevice, aResult );

        if( iOperation == ESspPairing && iNotifierUid == KBTNumericComparisonNotifierUid.iUid )

            {

            // Numeric comparison needs the boolean result passed back.

            TPckgBuf<TBool> userAcceptance( aResult );

            resultData.Set( userAcceptance );

            }

        if( aResult )

            {

            if( iOperation == ELegacyPairing || iOperation == EAutoPairing )

                {

                // Check the passkey entered by the user.

                // The length of the returned data equals the number of characters

                // entered by the user.