/*

* 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: 

*     Bio control for Provisioning documents.

*

*/

// INCLUDE FILES

#include "CWPBioControl.h"

#include <aknnotewrappers.h>

#include <msvapi.h>

#include <StringLoader.h>

#include <CRichBio.h>

#include <msgbiocontrolObserver.h>

#include <ProvisioningBC.rsg>

#include <bldvariant.hrh>

#include <msvids.h>

#include <biouids.h>

#include <featmgr.h>

#include <csxhelp/prov.hlp.hrh>

#include <sysutil.h>

#include "CWPEngine.h"

#include "CWPAdapter.h"

#include "MWPPhone.h"

#include "WPPhoneFactory.h"

#include "CWPPushMessage.h"

#include "CWPBootstrap.h"

#include "CWPSaver.h"

#include "ProvisioningUIDs.h"

#include "CWPCodeQueryDialog.h"

#include "MWPContextManager.h"

#include "ProvisioningDebug.h"

#include "CWPNameValue.h"

#include <aknmessagequerydialog.h> 

#include "ProvisioningInternalCRKeys.h"

// CONSTANTS

/// Strings are loaded from this resource

_LIT(KResourceFileName, "provisioningbc.rsc");

/// Maximum number of items with same title before they get merged.

const TInt KMaxDuplicates = 5;

/// Maximum length of PIN code

const TInt KMaxPinSize = 20;

/// Number of retries for PIN

// const TInt KPinRetries = 3; // Removed, because iMtmData1 data member of TMsvEntry in CWPMessage.cpp contains Max tries, default=3.

///NONE

_LIT(KNone,"");

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

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

// Constructor.

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

//

CWPBioControl::CWPBioControl( MMsgBioControlObserver& aObserver,

                              CMsvSession* aSession,

                              TMsvId aId,

                              TMsgBioMode aEditorOrViewerMode,

                              const RFile* aFile )

                            : CMsgBioControl( aObserver,

                                              aSession,

                                              aId,

                                              aEditorOrViewerMode,

                                              aFile )

    {

    }

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

// CNSmlDMSyncAppEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWPBioControl::ConstructL()

    {

    FLOG( _L( "[ProvisioningBC] CWPBioControl::ConstructL:" ) );

    FeatureManager::InitializeLibL();

    if( IsEditor() ) //This control does not support editing mode.

        {

        User::Leave( KErrNotSupported );

        }

    LoadResourceL(KResourceFileName);

    LoadStandardBioResourceL();

    iEngine = CWPEngine::NewL();

    iRichBio = new(ELeave) CRichBio( ERichBioModeEditorBase );

    // this function leaves if not enough data exists

    RestoreMsgL();

    // Add items to CRichBio

    AddItemsL();

    FLOG( _L( "[ProvisioningBC] CWPBioControl::ConstructL: done" ) );

    }

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

// CNSmlDMSyncAppEngine::NewL

// Two-phased constructor.

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

//

EXPORT_C CWPBioControl* CWPBioControl::NewL( MMsgBioControlObserver& aObserver,

                                             CMsvSession* aSession,

                                             TMsvId aId,

                                             TMsgBioMode aEditorOrViewerMode,

                                             const RFile* aFile )

    {

    CWPBioControl* self = new( ELeave ) CWPBioControl( aObserver,

                                                       aSession,

                                                       aId,

                                                       aEditorOrViewerMode,

                                                       aFile );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

CWPBioControl::~CWPBioControl()

    {

    delete iRichBio;

    delete iEngine;

    delete iMessage;

    FeatureManager::UnInitializeLib();

    }

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

// CWPBioControl::SetAndGetSizeL

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

//

void CWPBioControl::SetAndGetSizeL( TSize& aSize )

    {

    iRichBio->SetAndGetSizeL( aSize );

    SetSizeWithoutNotification( aSize );

    }

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

// CWPBioControl::SetMenuCommandSetL

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

//

void CWPBioControl::SetMenuCommandSetL( CEikMenuPane& aMenuPane )

    {

    AddMenuItemL( aMenuPane, R_MENU_SAVESETTING, ECmdSaveSettings );

    }

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

// CWPBioControl::CurrentLineRect

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

//

TRect CWPBioControl::CurrentLineRect() const

    {

    return iRichBio->CurrentLineRect();

    }

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

// CWPBioControl::IsFocusChangePossible

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

//

TBool CWPBioControl::IsFocusChangePossible(

                                         TMsgFocusDirection aDirection ) const

    {

    if (aDirection == EMsgFocusUp )

        {

        return iRichBio->IsCursorLocation( EMsgTop );

        }

    else

        {

        return EFalse;

        }

    }

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

// CWPBioControl::IsCursorLocation

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

//

TBool CWPBioControl::IsCursorLocation( TMsgCursorLocation aLocation ) const

    {

    return iRichBio->IsCursorLocation( aLocation );

    }

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

// CWPBioControl::HeaderTextL

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

//

HBufC* CWPBioControl::HeaderTextL() const

    {

    return StringLoader::LoadL( R_TITLE_PROVISIONING );

    }

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

// CWPBioControl::HandleBioCommandL()

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

//

TBool CWPBioControl::HandleBioCommandL(TInt aCommand)

    {

    TBool result( EFalse );

    if ( aCommand == iBioControlObserver.FirstFreeCommand() + ECmdSaveSettings )

        {

        SaveSettingsL();

        result = ETrue;

        }

    return result;

    }

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

// CWPBioControl::OptionMenuPermissionsL

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

//

TUint32 CWPBioControl::OptionMenuPermissionsL() const

    {

    TUint32 perm( EMsgBioDelete | EMsgBioMessInfo | EMsgBioMove | EMsgBioExit );

    if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

        {

        perm |= EMsgBioHelp;

        }

    return perm;

    }

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

// CWPBioControl::OfferKeyEventL

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

//

TKeyResponse CWPBioControl::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                            TEventCode aType )

    {

    return iRichBio->OfferKeyEventL( aKeyEvent, aType );

    }

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

// CWPBioControl::GetBioHelpContext

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

//

void CWPBioControl::GetHelpContext( TCoeHelpContext& aContext ) const

    {   

    if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

        {

        aContext.iContext = KPROV_HLP_PROVISIONVIEW() ;    

        aContext.iMajor = TUid::Uid( KProvisioningBCUid3 );

        }

    else

        {

        CCoeControl::GetHelpContext(aContext);

        }

    }

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

// CWPBioControl::CountComponentControls

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

//

TInt CWPBioControl::CountComponentControls() const

    {

    return 1;

    }

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

// CWPBioControl::ComponentControl

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

//

CCoeControl* CWPBioControl::ComponentControl( TInt /*aIndex*/ ) const

    {

    return iRichBio;

    }

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

// CWPBioControl::SizeChanged()

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

//

void CWPBioControl::SizeChanged()

    {

    iRichBio->SetExtent( Position(), iRichBio->Size() );

    }

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

// CWPBioControl::FocusChanged

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

//

void CWPBioControl::FocusChanged( TDrawNow aDrawNow )

    {

    iRichBio->SetFocus( IsFocused(), aDrawNow );

    }

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

// CWPBioControl::SetContainerWindowL

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

//

void CWPBioControl::SetContainerWindowL( const CCoeControl& aContainer )

    {

    CCoeControl::SetContainerWindowL( aContainer );

    iRichBio->ConstructL(this);

    }

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

// CWPBioControl ::VirtualHeight

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

//

TInt CWPBioControl::VirtualHeight()

    {

    return iRichBio->VirtualHeight();

    }

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

// CWPBioControl ::VirtualVisibleTop

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

//

TInt CWPBioControl::VirtualVisibleTop()

    {

    return iRichBio->VirtualVisibleTop();

    }

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

// CWPBioControl ::RestoreMsgL

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

//

void CWPBioControl::RestoreMsgL()

    {

    FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL" ) );

    // Load the message from Messaging Server

    CMsvEntry* entry = MsvSession().GetEntryL(iId);

    CleanupStack::PushL( entry );

    TMsvEntry tentry( entry->Entry() );

    iMessage = CWPPushMessage::NewL();

    CMsvStore* readStore = entry->ReadStoreL();

    CleanupStack::PushL( readStore );

    iMessage->RestoreL( *readStore );

    CleanupStack::PopAndDestroy(); // readStore

    FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL 1" ) );

    // Fill the engine

    TRAPD( result, iEngine->ImportDocumentL( iMessage->Body() ) );

    if( result == KErrCorrupt )

        {

        FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL KErrMsgBioMessageNotValid " ) );

        result = KErrMsgBioMessageNotValid;

        }

    FTRACE(RDebug::Print(_L("[ProvisioningBC] CWPBioControl::RestoreMsgL result (%d)"), result));

    User::LeaveIfError( result );

    FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL 2 " ) );

    TBool preAuthenticated( iMessage->Authenticated() );

    // If the message was not authenticated, give a warning

    AuthenticateL( *iMessage );

    FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL 3 " ) );

    if( !tentry.ReadOnly() && preAuthenticated != iMessage->Authenticated() )

        {

        // If the entry can be written to, get its edit store and save

        // authentication flag. Failing is not dangerous, as the only

        // effect is that the user has to re-enter the PIN.

        FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL 4 " ) );

        TRAPD( ignoreError, SaveMessageL() );

        if ( ignoreError ) ignoreError = 0; // prevent compiler warning	

        }

    FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL 5 " ) );

    iEngine->PopulateL();

    FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL 6 " ) );

    // Empty messages are not supported

    if( iEngine->ItemCount() == 0 )

        {

        FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL 7 " ) );

        User::Leave( KErrMsgBioMessageNotValid );

        }

    TPtrC8 orig8( iMessage->Originator() );

    HBufC* orig16 = HBufC::NewLC( orig8.Length() );

    orig16->Des().Copy( orig8 );

    FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL 8 " ) );

    if( iMessage->Authenticated() 

        && iEngine->ContextExistsL( *orig16 ) )

        {

        TUint32 context( iEngine->ContextL( *orig16 ) );

        iEngine->SetCurrentContextL( context );

        }

    else

        {

        iEngine->SetCurrentContextL( KWPMgrUidNoContext );

        }

    CleanupStack::PopAndDestroy(2); // orig16, entry

    FLOG( _L( "[ProvisioningBC] CWPBioControl::RestoreMsgL done" ) );

    }

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

// CWPBioControl ::AuthenticateL

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

//

void CWPBioControl::AuthenticateL( CWPPushMessage& aMessage )

    {

    if( !aMessage.Authenticated() )

        {

        // Try authentication and bootstrap without PIN.

	      MWPPhone* phone = NULL;

        TBuf<KMaxPinSize> imsi;

        TRAPD(err, phone = WPPhoneFactory::CreateL());

	     if(err!=KErrNone)

        {

		      imsi = KNone;

        }

        else

        {

        	imsi = phone->SubscriberId();

        }

        CWPBootstrap* bootstrap = CWPBootstrap::NewL( imsi );

        if(phone)

        delete phone;

	      CleanupStack::PushL( bootstrap );

        CWPBootstrap::TBootstrapResult result( bootstrap->BootstrapL( 

                                                                aMessage, 

                                                                *iEngine, 

                                                                KNullDesC ) );

        if( result == CWPBootstrap::EPinRequired )

            {

            	CMsvEntry* entry = MsvSession().GetEntryL(iId);

				TInt count = (entry->Entry()).MtmData1();

            // We need to ask the PIN. Retry max. MtmData1 (=3, default) times if

            // the user supplies from PIN.

            TBuf<KMaxPinSize> pin;

	            for( TInt i(0); i < count && !aMessage.Authenticated(); i++ )

                {

                pin.Zero();

				CWPCodeQueryDialog* dlg = 

				                        new (ELeave) CWPCodeQueryDialog( pin );

				if (dlg->ExecuteLD( R_QUERY_PIN ) == 0) //R_DATA_QUERY

				    {

					    delete entry;

					    entry = NULL;

                    //enable user cancelling at any phase

                    User::Leave( KLeaveWithoutAlert );

				    }

                result = bootstrap->BootstrapL( aMessage, *iEngine, pin );

                // Wrong PIN. Give a note except on the last time. 

                // Then the user will get note 

                // R_QUERY_VERIFIC_FAILED_TOTALLY with OK key.

                if( result == CWPBootstrap::EAuthenticationFailed 

	                    && i < (const_cast <TMsvEntry&> (entry->Entry())).iMtmData1--)

                    {

	                      entry->ChangeL(entry->Entry());

						i--;	                    

						count = (entry->Entry()).MtmData1(); //(const_cast <TMsvEntry&> (entry->Entry())).iMtmData1;

                    ErrorNoteL( R_TEXT_WRONG_PIN );

                    }

                }

            // Still wrong PIN -> tell the user and delete the message.

            if( !aMessage.Authenticated() )

                {

					delete entry;

					entry = NULL;

                CAknNoteDialog* dlg = new(ELeave) CAknNoteDialog;

                dlg->ExecuteLD(R_QUERY_VERIFIC_FAILED_TOTALLY);

                MsvSession().RemoveEntry( iId );

                User::Leave( KLeaveWithoutAlert );

                }

	             if(entry)

	             {

	             	delete entry;

	             }

            }

        if(result == CWPBootstrap::EAuthenticationFailed)

        {

        		CAknMessageQueryDialog* msg =  new(ELeave) CAknMessageQueryDialog;

        		msg->ExecuteLD(R_MSG_AUTHENTICATION_FAILED);

			MsvSession().RemoveEntry( iId );

        		User::Leave( KLeaveWithoutAlert );

        }

        CleanupStack::PopAndDestroy( bootstrap );