/*

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

#include "btnotifclientserver.h"

#include <btextnotifiers.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <btextnotifierspartner.h>

#endif

#include "btnotifconnectiontracker.h"

#include "btnotifsecuritymanager.h"

#include "btnotificationmanager.h"

#include "bluetoothnotification.h"

#include "btnotifserver.h"

#include "btnotifbasepairinghandler.h"

#include "bluetoothtrace.h"

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

_LIT( KNumCompFormat, "%06u" );

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

_LIT( KPassKeyFormat, "%06u" );

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

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

// C++ default constructor.

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

//

CBTNotifPairNotifier::CBTNotifPairNotifier(

        CBTNotifSecurityManager& aParent )

:   iParent( aParent )

    {

    }

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

// Symbian 2nd-phase constructor.

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

//

void CBTNotifPairNotifier::ConstructL()

    {

    }

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

// NewL

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

//

CBTNotifPairNotifier* CBTNotifPairNotifier::NewL(

        CBTNotifSecurityManager& aParent )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    CBTNotifPairNotifier* self = new( ELeave ) CBTNotifPairNotifier( aParent );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    return self;

    }

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

// Destructor.

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

//

CBTNotifPairNotifier::~CBTNotifPairNotifier()

    {

    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;

        }

    iParams.Close();

    if ( !iNotifierMessage.IsNull() )

        {

        iNotifierMessage.Complete( KErrServerTerminated );

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// Handle a notifier request for pairing with a remote device.

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

//

void CBTNotifPairNotifier::StartPairingNotifierL(const RMessage2& aMessage )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    TInt uid = aMessage.Int0();

    TInt opCode = aMessage.Function();

    if ( (!iNotifierMessage.IsNull()) && 

         (opCode != EBTNotifCancelNotifier )&&(opCode != EBTNotifUpdateNotifier))

        {

        // todo: do we allow concurrent pairing?

        User::Leave(KErrServerBusy );

        }

    if(opCode == EBTNotifCancelNotifier)

        {

        CancelPairingNotifierL(uid);

        aMessage.Complete(KErrNone);

        return;

        }

    if(opCode != EBTNotifUpdateNotifier)

        {

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

        iParams.CreateL( aMessage.GetDesLengthL( EBTNotifSrvParamSlot ) );

        aMessage.ReadL( EBTNotifSrvParamSlot, iParams );

        iNotifierMessage = aMessage;

        // Read the notifier parameters

        ParseNotifierReqParamsL();

        }

    if(opCode ==EBTNotifUpdateNotifier )

        {

        UpdatePairingNotifierL(aMessage);

        aMessage.Complete(KErrNone);

        return;

        }

    const CBtDevExtension* dev = iParent.BTDevRepository().Device(iRemote);

    if(dev)

        {

        if (!iLocallyInitiated && dev->Device().GlobalSecurity().Banned() )

            {

            // If the device is banned and pairing is not locally initiated

            // then we reject.

            iNotifierMessage.Complete( KErrCancel );

            return;

            }

        if (iLocallyInitiated && dev->Device().GlobalSecurity().Banned())

            {

            // Remove the banned device from the blocking history

            iParent.ConnectionTracker().UpdateBlockingHistoryL(&dev->Device(),ETrue);

            iParent.BlockDevice(dev->Addr(),EFalse);

            }

        if(0 != dev->Device().FriendlyName().Length()&& dev->Device().IsValidFriendlyName())

            {

            // If we have a friendly name use it for the UI

            iCurrentDeviceName = dev->Device().FriendlyName();

            }

        else

            {

            // We don't have any friendly name then check if we have the device name

            // otherwise use the Alias

            if(0 >= iCurrentDeviceName.Length())

                {

                iCurrentDeviceName = dev->Alias();

                }

            }

        }

    else

        {

        //If we didn't get a name then we make one from the Bluetooth device address

        if(0 >= iCurrentDeviceName.Length())

            {

            iRemote.GetReadable(iCurrentDeviceName);

            }

        }

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

    if( !iLocallyInitiated  )

        {

        User::LeaveIfError(iParent.SetPairObserver(iRemote,ETrue));

        StartAcceptPairingQueryL();

        }

    else

        {

        if(uid == KBTNumericComparisonNotifierUid.iUid || uid == KBTPasskeyDisplayNotifierUid.iUid)

            {

            StartPairingUserInputL();

            }

        else

            {

            TBTPinCode pinCode;

            if ( iMinPinLength > -1 )

                {

                // Legacy Pin pairing. Check if a pin code is already available

                // in pairing manager for this device:

                iParent.GetPinCode( pinCode, iRemote, iMinPinLength );

                }

            if ( pinCode().iLength > 0 )        

                {

                // a pin is ready for this pairing.

                // write it back to client (stack)

                TInt err = iNotifierMessage.Write( EBTNotifSrvReplySlot, pinCode );

                iNotifierMessage.Complete( err );

                }

            else

                {

                // no pin code is available or a pin code does not meet

                // the security requirement.

                // User need to interact:

                StartPairingUserInputL();

                }

            }

        }

    BOstraceFunctionExit1( DUMMY_DEVLIST, this );

    }

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

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

// is currently being served.

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

//

void CBTNotifPairNotifier::UpdatePairingNotifierL( const RMessage2& aMessage )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    RBuf8 msgParams;

    msgParams.CreateL( aMessage.GetDesLengthL( EBTNotifSrvParamSlot ) );

    aMessage.ReadL( EBTNotifSrvParamSlot, msgParams );

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

    TPckgC<TBTNotifierUpdateParams2> paramsPckg( params );

    paramsPckg.Set( msgParams );

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

        {

        // Paskey display update - keypress on remote device.

        TBTPasskeyDisplayUpdateParams keyUpdate;

        TPckgC<TBTPasskeyDisplayUpdateParams> keyUpdatePckg( keyUpdate );

        keyUpdatePckg.Set(msgParams);

        THCIPasskeyEntryNotificationType keyType = keyUpdatePckg().KeypressNotification();

        if( iNotification )

            {

            // Update the dialog

            iNotification->Update(keyType);

            }        

        }

    else

        {

        // name update

        TBTDeviceNameUpdateParams nameUpdate;

        TPckgC<TBTDeviceNameUpdateParams> nameUpdatePckg( nameUpdate );

        nameUpdatePckg.Set( msgParams );

        // The result means result of conversion to unicode

        if( !nameUpdatePckg().Result() )

            {

            // Check first if we already have a friendly name

            const CBtDevExtension* dev = iParent.BTDevRepository().Device(iRemote);

            if(dev)

                {

                if(0 != dev->Device().FriendlyName().Length()&& dev->Device().IsValidFriendlyName())

                    {

                    iCurrentDeviceName = dev->Device().FriendlyName();

                    }

                else

                    {

                    // We don't have a friendly name then use this name

                    iCurrentDeviceName = nameUpdatePckg().DeviceName();

                    if(0 == iCurrentDeviceName.Length())

                        {

                        // The new name is empty then use the Alias

                        iCurrentDeviceName = dev->Alias();

                        }

                    }

                }

            else

                {

                // We don't have a friendly name then use this name

                iCurrentDeviceName = nameUpdatePckg().DeviceName();

                if(0 == iCurrentDeviceName.Length())

                    {

                    // The new name is empty then use the Alias

                    iRemote.GetReadable(iCurrentDeviceName);

                    }

                }

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

                }

            }

        }

    msgParams.Close();

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

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

// is currently being served.

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

//

void CBTNotifPairNotifier::CancelPairingNotifierL( TInt aUid )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if(  iNotifierMessage.Int0() == aUid )

        {

        if( iNotification )

            {

            // Cancel the user query

            // This will also unregister us from the notification.

            TInt err = iNotification->Close();

            NOTIF_NOTHANDLED( !err )

            iNotification = NULL;

            }

        // todo: Any bonding requester needs to be informed.

        // Currently we don't show any "Unable to pair" note

        // so no need to inform any bonding requester.

        if ( !iNotifierMessage.IsNull() )

            {

            iNotifierMessage.Complete( KErrCancel );

            }

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// From class MBTNotificationResult.

// Handle a result from a user query.

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

//

void CBTNotifPairNotifier::MBRDataReceived( CHbSymbianVariantMap& aData )

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    if(aData.Keys().MdcaPoint(0).Compare(_L("actionResult")) == 0)

        {

        TInt val = *(static_cast<TInt*>(aData.Get(_L("actionResult"))->Data()));

        if(val)

            {

                iAcceptPairingResult = ETrue;

            }

        else

            {

                iAcceptPairingResult = EFalse;

            }

        }

    else if(aData.Keys().MdcaPoint(0).Compare(_L("checkBoxState")) == 0)

        {

        iCheckBoxState = *(static_cast<TInt*>(aData.Get(_L("checkBoxState"))->Data()));

        }

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// From class MBTNotificationResult.

// The notification is finished.

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

//

void CBTNotifPairNotifier::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 ) );

    BOstraceFunctionExit1( DUMMY_DEVLIST, this );

    }

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

// Request a user input for the outstanding pairing request.

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

//

void CBTNotifPairNotifier::StartPairingUserInputL()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    PrepareNotificationL( iDialog, iDialogResource );

    iState = EPairingInputConfirm;

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

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

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

//

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

    const TDesC8& aData )

    {

    BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aError );

    if ( iNotifierMessage.IsNull() )

        {

        // Request not anymore active -> ignore

        return;

        }

    TInt err = aError;

    TPtrC8 resultData(KNullDesC8);

    TBTPinCode pinCode;

    TPckgBuf<TBool> userAcceptance;

    TInt uid = iNotifierMessage.Int0();

    if( !err )

        {

        // The returned data is the entered passkey.

        const CBtDevExtension* dev = iParent.BTDevRepository().Device(iRemote);

        if(dev)

            {

            iParent.ConnectionTracker().UpdateBlockingHistoryL(&dev->Device(),aResult);

            }

         if( uid == KBTNumericComparisonNotifierUid.iUid )

            {

            // Numeric comparison needs the boolean result passed back.

            userAcceptance() = aResult;

            resultData.Set( userAcceptance );

            }

         if( aResult )

            {

            if( uid == KBTManPinNotifierUid.iUid 

                || uid == KBTPinCodeEntryNotifierUid.iUid )

                {

                // Check the passkey entered by the user.

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

                // entered by the user.

                // Check that the passkey length do not exceed the maximum allowed size

                TInt pinCodeLength = aData.Length();

                if(pinCodeLength > KHCIPINCodeSize)

                    {

                        pinCodeLength = KHCIPINCodeSize;

                    }

                pinCode().iLength = pinCodeLength;

                // Check that the length of the passkey meets the minimum 

                // required pin code length

                if( pinCodeLength >= iMinPinLength )

                    {

                    for( TInt i = 0; i < pinCodeLength; i++ )

                        {

                        pinCode().iPIN[i] = aData[i];

                        }

                    resultData.Set( pinCode );

                    }

                else

                    {

                    // shouldn't happen since the length is checked in the dialog

                    err = KErrCompletion;

                    }

                }

            }

        else

            {

            err = KErrCancel;

            }

        }

    // Complete the message with the result, and result data if any.

    if ( !err && resultData.Length() )

        {

        err = iNotifierMessage.Write( EBTNotifSrvReplySlot, resultData );

        }

    if(err && (uid == KBTNumericComparisonNotifierUid.iUid))

        {

        // We need to reject the numeric comparaison otherwise

        // the link will remain active

        userAcceptance() = aResult;

        resultData.Set( userAcceptance );

        err = iNotifierMessage.Write( EBTNotifSrvReplySlot, resultData );

        }

    iNotifierMessage.Complete( err );

    BOstraceFunctionExit1( DUMMY_DEVLIST, this );

    }

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

// Ask the user to allow incoming pairing.

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

//

void CBTNotifPairNotifier::StartAcceptPairingQueryL()

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    PrepareNotificationL( TBluetoothDialogParams::EUserAuthorization, EAuthorization );

    iState = EIncomingPairingAcceptconfirm;

    // if rejected, the client message is completed in CompleteAcceptPairingQueryL

    BOstraceFunctionExit0( DUMMY_DEVLIST );

    }

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

// The user was asked to accept an incoming pairing. Process and proceed. 

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

//

void CBTNotifPairNotifier::CompleteAcceptPairingQueryL( TInt aError)

    {

    BOstraceFunctionEntry0( DUMMY_DEVLIST );

    TInt err = aError;

    TBool proceed = EFalse;

    if( !err )

        {

        const CBtDevExtension* dev = iParent.BTDevRepository().Device(iRemote);

        if(dev)

            {

            proceed = iParent.ConnectionTracker().UpdateBlockingHistoryL(&dev->Device(),iAcceptPairingResult);

            }

        if( iAcceptPairingResult )

            {

            if(iCheckBoxState)

                {

                (iParent.PairingHandler())->SetTrusted();

                }

            StartPairingUserInputL();

            }

        else

            {

            if( proceed && iCheckBoxState )

                {

                //ask to block the device.

                iParent.BlockDevice(iRemote,proceed);