/*

* Copyright (c) 2002 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:  Declares authentication (PIN query) notifier class.

*

*/

// INCLUDE FILES

#include <StringLoader.h>    // Localisation stringloader

#include <utf.h>             // Unicode character conversion utilities

#include <avkon.mbg>

#include <btengconnman.h>

#include <btotgpairpub.inl>

#include <btextnotifiers.h>

#include <BTNotif.rsg>       // Own resources

#include "btnotif.hrh"       // Own resource header

#include "btnpinnotifier.h"  // Own class definition

#include "btNotifDebug.h"    // Debugging macros

#include "btnotifnameutils.h"

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <btextnotifiers.h>

#else

#include <btextnotifiers.h>

#include <btextnotifierspartner.h>

#endif

#include <SecondaryDisplay/BTnotifSecondaryDisplayAPI.h>

#ifdef __SERIES60_HELP

#include <hlplch.h>

#include <csxhelp/bt.hlp.hrh> // The bt hrh info is needed, for help launching

#endif

const TInt KDefaultPinCodeLength=4;

const TUint8 KZeroPinValue = '0';

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

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

// CBTPinNotifier::NewL

// Two-phased constructor.

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

//

CBTPinNotifier* CBTPinNotifier::NewL()

    {

    CBTPinNotifier* self=new (ELeave) CBTPinNotifier();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CBTPinNotifier::CBTPinNotifier

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CBTPinNotifier::CBTPinNotifier()

    {    

    }

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

// Destructor

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

//

CBTPinNotifier::~CBTPinNotifier()

    {

    }

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

// CBTPinNotifier::RegisterL

// Register notifier.

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

//

CBTPinNotifier::TNotifierInfo CBTPinNotifier::RegisterL()

    {

    iInfo.iUid=KBTPinCodeEntryNotifierUid;

    iInfo.iChannel=KBTAuthenticationChannel;

    iInfo.iPriority=ENotifierPriorityVHigh;

    return iInfo;

    }

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

// CBTPinNotifier::GetParamsL

// Initialize parameters and check if device is already

// in registry. Jump to RunL as soon as possible.

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

//

void CBTPinNotifier::GetParamsL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

    {

    FLOG(_L("[BTNOTIF]\t CBTPinNotifier::GetParamsL() >>"));

    CBTNPairNotifierBase::GetParamsL( aBuffer, aReplySlot, aMessage );

    TBTPinCodeEntryNotifierParams param;

 	TPckgC<TBTPinCodeEntryNotifierParams> pckg(param);

 	pckg.Set(aBuffer);

    iBTAddr = pckg().DeviceAddress();

    if ( OtherOutgoPairing(iBTAddr) )

        {

        // We won't allow incoming pairing during outgoing pairing:

        FLOG(_L("[BTNOTIF]\t CBTPinNotifier: outgoing pair in progress, reject incoming pair"));

        CompleteMessage(KErrCancel);

        return;

        }

 	iLocallyInitiated = pckg().LocallyInitiated();

    iPasskeyLength = pckg().PinCodeMinLength();

    iStrongPinRequired = pckg().StrongPinCodeRequired();

    ProcessParamsGetDeviceL( iBTAddr, pckg().DeviceName() );

    FLOG(_L("[BTNOTIF]\t CBTPinNotifier::GetParamsL() <<"));

    }

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

// CBTPinNotifier::HandleGetDeviceCompletedL

// Ask user response and return it to caller.

// Store device into registry if user has accepted pairing.

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

//

void CBTPinNotifier::HandleGetDeviceCompletedL(const CBTDevice* aDev)

    {

    FLOG(_L("[BTNOTIF]\t CBTPinNotifier::HandleGetDeviceCompletedL() >>"));

    (void) aDev;

    // Check if blocked device  

    if( CheckBlockedDeviceL() )

        return;

    // Turn lights on and deactivate apps -key

    iNotifUiUtil->TurnLightsOn();

    if( CheckAndSetAutomatedPairing() )

        {

        CompleteMessage(iPinCode, KErrNone);

        return;

        }

    // For incoming pairing request

    if(!iLocallyInitiated)

    	{

    	TBool userAnswer = AuthoriseIncomingPairingL();

        if( !userAnswer )

            {

            //User rejects the incoming pairing, complete message in QueryBlockDevice.

            FLOG(_L("[BTNOTIF]\t CBTPinNotifier::HandleGetDeviceCompletedL() <<"));

            return;

            }

    	}

	// Use a forever loop here to show query dialog again of ínput pin code does't fulfill the

	// minimum length requirement 

	//      

 	FOREVER

	 	{

	    TBuf<KBTPassKeyMaxLength> tempResultBuffer;

	    HBufC* prompt = GenerateQueryPromoptLC(); // prompt still in stack.

        TInt keypress = iNotifUiUtil->ShowTextInputQueryL(tempResultBuffer, *prompt, R_BT_ENTER_PASSKEY_QUERY, 

                ECmdShowBtOpenCoverNote, CAknQueryDialog::EConfirmationTone );

        CleanupStack::PopAndDestroy( prompt );

        if( keypress ) // OK pressed

        	{

       		// Convert data from buf to pin

        	TBuf8<KBTPassKeyMaxLength> buf8;

        	buf8.Zero();

        	CnvUtfConverter::ConvertFromUnicodeToUtf8(buf8, tempResultBuffer);

        	    //check if the length of pin less that minimum required pin code length

        	if ((iPasskeyLength == 0) || ( buf8.Length() >= iPasskeyLength))

        		{

			    iPinCode().iLength = STATIC_CAST(TUint8, buf8.Length());

			    for (TInt index=0; index<buf8.Length(); index++)

			        {

			        iPinCode().iPIN[index] = buf8[index];

			        }

			   	CompleteMessage(iPinCode, KErrNone);

        		break;

        		}

        	else 

        		{

        		//keep FOREVER loop runing, till the user input pin meet the requirement.

        		tempResultBuffer.Zero();

        		}

        	}

	    else    // Cancel pressed

	        {

            // If the outgoing pairing mode is set, then this is bonding initiated by the user.

            TBool incomingConn = ( OutgoPairingMode( iBTAddr ) == EBTOutgoingPairNone );

            if( !iMessage.IsNull() )

                {

                // No need to inform the user of the pairing result if the user cancelled it.

                // If user doesn't answer anything but stack cancels, pairing result is needed 

                // to show for outgoing pairing. In this case, don't stop pairng observer.

                CBTEngConnMan::StopPairingObserver( iBTAddr );    

                }

            // We may be asking for pairing (locally initiated), because a remote device is requesting

            // accesss to a service for which we require authentication.

            if( iLocallyInitiated && incomingConn )

                {

                CheckAndHandleQueryIntervalL();

                }

            CompleteMessage(KErrCancel);

	        return;

	        }

	 	}//END of FOREVER loop

    FLOG(_L("[BTNOTIF]\t CBTPinNotifier::HandleGetDeviceCompletedL() completed"));

    }

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

// CBTPinNotifier::CheckAndSetAutomatedPairing

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

TBool CBTPinNotifier::CheckAndSetAutomatedPairing()

    {

    FLOG(_L("[BTNOTIF]\t CBTPinNotifier::CheckAndSetAutomatedPairing()"));    

    TBool ret( EFalse );

    // check if device is headset and passkey is empty -> do automated pairing with 0000.

	if ( iDevice && 

	     OutgoPairingMode( iBTAddr ) == EBTOutgoingHeadsetAutoPairing && 

	     iPasskeyLength <= KDefaultPinCodeLength )

	    {

	    FLOG( _L( "[BTNOTIF]\t CBTPinNotifier::CheckAndSetAutomatedPairing - automated pairing on" ) );

	    FLOG(_L("[BTNOTIF]\t Setting default PIN code"));

	    iPinCode().iLength = KDefaultPinCodeLength;

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

	        {

	        iPinCode().iPIN[i] = KZeroPinValue;

	        }

	    ret = ETrue;

	    }

	return ret;

    }

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

// CBTPinNotifier::GenerateQueryPromoptLC

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

HBufC* CBTPinNotifier::GenerateQueryPromoptLC()

    {

    FLOG(_L("[BTNOTIF]\t CBTPinNotifier::GenerateQueryPromoptLC() >>"));

    HBufC* prompt = NULL;

    TBTDeviceName devName;

    BtNotifNameUtils::GetDeviceDisplayName( devName, iDevice );

    if (iPasskeyLength > 0)  //Minimum length passkey is defined

        {

        CDesCArray* stringArray = new ( ELeave ) CDesCArrayFlat( 1 );

        CleanupStack::PushL( stringArray );

        CArrayFix<TInt>* indexArray = new(ELeave) CArrayFixFlat<TInt>(1);

        CleanupStack::PushL( indexArray ); 

        stringArray->AppendL( BTDeviceNameConverter::ToUnicodeL(iDevice->DeviceName()) );   

        indexArray->AppendL( iPasskeyLength);   

        prompt = StringLoader::LoadL( R_BT_MIN_PASSKEY_PROMPT, *stringArray, *indexArray );

        CleanupStack::PopAndDestroy( indexArray );

        CleanupStack::PopAndDestroy( stringArray );

        CleanupStack::PushL( prompt );

        }

    else

        {

        prompt = StringLoader::LoadLC( R_BT_PASSKEY_PROMPT, devName );

        }

    FLOG(_L("[BTNOTIF]\t CBTPinNotifier::GenerateQueryPromoptLC() <<"));

    return prompt;

    }

// End of File