/*
* 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 <btengdevman.h>
#include <btengconnman.h>
#include <btotgpairpub.inl>
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <btextnotifiers.h>
#else
#include <btextnotifiers.h>
#include <btextnotifierspartner.h>
#endif
#include <BTNotif.rsg>       // Own resources
#include <SecondaryDisplay/BTnotifSecondaryDisplayAPI.h>
#include <bluetoothuiutil.h>
#include "btnotif.hrh"       // Own resource header
#include "btnssppasskeyentrynotifier.h"  // Own class definition
#include "btNotifDebug.h"    // Debugging macros
#include "btnotifnameutils.h"

#ifdef __SERIES60_HELP
#include <hlplch.h>
#include <csxhelp/bt.hlp.hrh> // The bt hrh info is needed, for help launching
#endif


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

// ----------------------------------------------------------
// CBTSSPPasskeyEntryNotifier::NewL
// Two-phased constructor.
// ----------------------------------------------------------
//
CBTSSPPasskeyEntryNotifier* CBTSSPPasskeyEntryNotifier::NewL()
    {
    CBTSSPPasskeyEntryNotifier* self=new (ELeave) CBTSSPPasskeyEntryNotifier();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// ----------------------------------------------------------
// CBTSSPPasskeyEntryNotifier::CBTSSPPasskeyEntryNotifier
// C++ default constructor can NOT contain any code, that
// might leave.
// ----------------------------------------------------------
//
CBTSSPPasskeyEntryNotifier::CBTSSPPasskeyEntryNotifier()
    {
    iPasskey.Zero();
    }

// ----------------------------------------------------------
// Destructor
// ----------------------------------------------------------
//
CBTSSPPasskeyEntryNotifier::~CBTSSPPasskeyEntryNotifier()
    {
    }

// ----------------------------------------------------------
// CBTSSPPasskeyEntryNotifier::RegisterL
// Register notifier.
// ----------------------------------------------------------
//
CBTSSPPasskeyEntryNotifier::TNotifierInfo CBTSSPPasskeyEntryNotifier::RegisterL()
    {
    iInfo.iUid = KBTPasskeyDisplayNotifierUid;
    iInfo.iChannel = KBTPasskeyDisplayNotifierUid;
    iInfo.iPriority = ENotifierPriorityVHigh;
    return iInfo;
    }

// ----------------------------------------------------------
// CBTSSPPasskeyEntryNotifier::GetParamsL
// Initialize parameters and check if device is already
// in registry. Jump to RunL as soon as possible.
// ----------------------------------------------------------
//
void CBTSSPPasskeyEntryNotifier::GetParamsL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)
    {
    FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::GetParamsL()"));

    CBTNPairNotifierBase::GetParamsL( aBuffer, aReplySlot, aMessage );
    
    TBTPasskeyDisplayParamsPckg pckg;
    pckg.Copy(aBuffer);
    iBTAddr = pckg().DeviceAddress();
    if ( OtherOutgoPairing(iBTAddr) )
        {
        // We won't allow incoming pairing during outgoing pairing:
        FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier: outgoing pair in progress, reject incoming pair"));
        CompleteMessage(KErrCancel);
        return;
        }

    iLocallyInitiated = pckg().LocallyInitiated();
    iPasskey.AppendNumFixedWidth(pckg().NumericalValue(), EDecimal, KPassKeylength);
    iPasskey.Insert(3,_L(" "));

    ProcessParamsGetDeviceL( iBTAddr, pckg().DeviceName() );
    
    FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::GetParamsL() completed"));
    }

// ----------------------------------------------------------
// CBTSSPPasskeyEntryNotifier::UpdateL
// Notifier update. Stores the received bluetooth
// device name into registry and show it on screen.
// ----------------------------------------------------------
//
TPtrC8 CBTSSPPasskeyEntryNotifier::UpdateL(const TDesC8& aBuffer)
    {
    FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::UpdateL()"));
    
    TBTPasskeyDisplayUpdateParamsPckg pckg;
    pckg.Copy(aBuffer);
  
    if(pckg().Type() != TBTNotifierUpdateParams2::EPasskeyDisplay)
        {
        TPtrC8 ret(KNullDesC8);
        return (ret);
        }
    
    switch (pckg().KeypressNotification())
        {
        case EPasskeyEntryStarted:
            {
            iBuf.Zero();
            iBuf.Append(iPasskey);
            iBuf.Append(_L("    "));
            break;
            }
        case EPasskeyDigitEntered:
            {
            // show an '*'
            iBuf.Append(_L("*"));
            break;
            }
        case EPasskeyDigitDeleted:
            {
            // remove an '*' from the tail of iBuf
            iBuf.Delete(iBuf.Length()-1, 1);  
            break;
            }
        case EPasskeyCleared:
            {
            // remove all '*'
            iBuf.Zero();
            iBuf.Append(iPasskey);
            iBuf.Append(_L("    "));
            break;
            }
        case EPasskeyEntryCompleted:
            {                                  
            // complete passkey entry
            // Set iAnswer to 1 ,
            // Continue pairing in Run()
            iAnswer = 1;
            //iPasskeyDlg->DismissQueryL();
            iNotifUiUtil->DismissDialog();
            break;
            }
        }
    if ( !iNotifUiUtil->IsQueryReleased() )
        {
        RBuf prompt;
        prompt.CleanupClosePushL();
        GenerateQueryPromptL( prompt );
        iNotifUiUtil->UpdateQueryDlgL( prompt );
        CleanupStack::PopAndDestroy( &prompt ); 
        }        
    
    FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::UpdateL() completed"));
    TPtrC8 ret(KNullDesC8);
    return (ret);
    }

// ----------------------------------------------------------
// CBTSSPPasskeyEntryNotifier::HandleGetDeviceCompletedL
// Ask user response and return it to caller.
// Store device into registry if user rejects the incoming pairing.
// ----------------------------------------------------------
//
void CBTSSPPasskeyEntryNotifier::HandleGetDeviceCompletedL(const CBTDevice* /*aDev*/)
    {
    FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::HandleGetDeviceCompletedL()"));
    iAnswer = 0;
    
    // Check if blocked device. 
    if( CheckBlockedDeviceL() )
        return;

    // For pairing request from remote device
    if ( !iLocallyInitiated )
        {
        TBool keypress = AuthoriseIncomingPairingL();
        if( !keypress )
            {
            //User rejects the incoming pairing, complete message in QueryBlockDevice.
            FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::HandleGetDeviceCompletedL() <<"));
            return;
            }
        }
   
    TBTDeviceName nameCoverUi( KNullDesC );
    
    iBuf.Zero();
    iBuf.Append(iPasskey);
    iBuf.Append(_L("    "));
    
    RBuf prompt;
    prompt.CleanupClosePushL();
    GenerateQueryPromptL( prompt );
    
    TInt answer = iNotifUiUtil->ShowQueryL( prompt, R_BT_PASSKEY_QUERY, 
            ECmdBTnotifUnavailable, nameCoverUi );    
    CleanupStack::PopAndDestroy( &prompt );  

    if( iAnswer ) // user pressed entry key from remote keyboard.
        {
        CompleteMessage(KErrNone);
        }
    else 
        {
        // 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.
            (void) 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);
        }
    
     FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::HandleGetDeviceCompletedL() completed"));
    }

// ----------------------------------------------------------
// CBTSSPPasskeyEntryNotifier::GenerateQueryPromptL
// ----------------------------------------------------------
//
void CBTSSPPasskeyEntryNotifier::GenerateQueryPromptL(  RBuf& aRBuf )
    {
    FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::GenerateQueryPromptL()"));
    TBTDeviceName devName; 
    BtNotifNameUtils::GetDeviceDisplayName(devName, iDevice);   
    BluetoothUiUtil::LoadResourceAndSubstringL( 
            aRBuf, R_BT_SSP_PASSKEY_ENTRY, devName, 0 );
    BluetoothUiUtil::AddSubstringL( aRBuf, iBuf, 1 );
    FLOG(_L("[BTNOTIF]\t CBTSSPPasskeyEntryNotifier::GenerateQueryPromptL() << "));

    }
// End of File