/*

* 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 <msvapi.h>

#include <bldvariant.hrh>

#include <msvids.h>

#include <featmgr.h>

#include <sysutil.h>

#include <CWPEngine.h>

#include <CWPAdapter.h>

#include <MWPPhone.h>

#include <WPPhoneFactory.h>

#include <CWPPushMessage.h>

#include "ProvisioningUIDs.h"

#include <MWPContextManager.h>

#include "ProvisioningDebug.h"

#include "CWPNameValue.h"

#include <aknmessagequerydialog.h> 

#include <ProvisioningInternalCRKeys.h>

#include <HbMessageBox>

#include <HbAction>

#include <QVariant>

#include <hbdevicedialog.h>

#include <QObject>

#include <devicedialogconsts.h>

#include "PnpUtilLogger.h"

// CONSTANTS

_LIT(KNone,"");

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

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

// Constructor.

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

//

CWPBioControl::CWPBioControl(CMsvSession* /*aSession*/,TMsvId /*aId*/): CActive(EPriorityNormal)

    {

		CActiveScheduler::Add( this );

    }

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

// CWPBioControl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWPBioControl::ConstructL(CMsvSession* aSession,TMsvId aId,CpQtSp* sp)

    {

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

    FeatureManager::InitializeLibL();

    iSession = aSession;

    iId = aId;

    iSp = sp;

    iEngine = CWPEngine::NewL();    

    iDevDialog = NULL;

    ibootstrap = NULL;

    iMsg = new(ELeave)CpMessage(this);

    iWait = new( ELeave ) CActiveSchedulerWait;

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

    }

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

// CWPBioControl::NewL

// Two-phased constructor.

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

//

EXPORT_C CWPBioControl* CWPBioControl::NewL(CMsvSession* aSession,TMsvId aId,CpQtSp* sp)

     {

    CWPBioControl* self = new( ELeave ) CWPBioControl(aSession,aId);                                                       

    CleanupStack::PushL( self );

    self->ConstructL(aSession,aId,sp);

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

CWPBioControl::~CWPBioControl()

    {

    Cancel();

    delete iEngine;

    delete iMessage;

    FeatureManager::UnInitializeLib();

    if (iDevDialog)

        {

        delete iDevDialog;

        iDevDialog = NULL;

        }

    delete ibootstrap;

    delete iWait;

    if ( iMsg )

    {

    	delete iMsg;

    	iMsg = NULL;

    }

    }

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

// CWPBioControl ::RestoreMsgL

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

//

void CWPBioControl::RestoreMsgL()

    {                    

    CMsvEntry* entry = iSession->GetEntryL(iId);   

    CleanupStack::PushL( entry );

    iEntry = entry->Entry();

    iMessage = CWPPushMessage::NewL();

    CMsvStore* readStore = entry->ReadStoreL();

    CleanupStack::PushL( readStore );

    iMessage->RestoreL( *readStore );

    CleanupStack::PopAndDestroy(); // readStore

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

    if( result == KErrCorrupt )

        {

        //result = KErrMsgBioMessageNotValid;

        }

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

	AuthenticateL( *iMessage );

	CleanupStack::PopAndDestroy();

	if(iAuth == KAUTENTICATIONCANCEL || iAuth == KAUTENTICATIONSUCCESS)

	    {

        iSp->authenticationStatus();

	    }	

    }

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

// CWPBioControl ::postAuthetication

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

//

void CWPBioControl::postAuthetication()

    {    

    iMsg->senderUnknown();

    }      

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

// CWPBioControl ::senderUnknownContinue

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

//

void CWPBioControl::senderUnknownContinue()

    {

    iAuth = KAUTENTICATIONSUCCESS;

    iSp->authenticationStatus();

    }

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

// CWPBioControl ::senderUnknownCancel

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

//

void CWPBioControl::senderUnknownCancel()

    {

    iAuth = KAUTENTICATIONCANCEL;

    iSp->authenticationStatus();

    }

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

// CWPBioControl ::updateAuthetication

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

//

void CWPBioControl::updateAuthetication()

{

    if (iMessage->Authenticated() )

           {

           //update Cenrep key

           TBuf8<100> orig;

           orig.Copy(iMessage->Originator());

           TRAPD(err, SetCenrepKeyL(orig));

           User::LeaveIfError(err);

           }

        {

        // 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 

        }

    iEngine->PopulateL();

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

        {

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

        }

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

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

}

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

// CWPBioControl ::getAuth

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

//

TInt CWPBioControl::getAuth()

    {

    return iAuth;

    }

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

// CWPBioControl ::RestoreMsgL

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

//	

TBool CWPBioControl::AuthenticateL( CWPPushMessage& aMessage )

    {

     if (!aMessage.Authenticated())

        {

        MWPPhone* phone = NULL;

        TBuf<KMaxPinSize> imsi;

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

        if (err != KErrNone)

            {

            imsi = KNone;

            }

        else

            {

            imsi = phone->SubscriberId();

            }

        ibootstrap = CWPBootstrap::NewL(imsi);

        if (phone)

            delete phone;

        CWPBootstrap::TBootstrapResult result(ibootstrap->BootstrapL(aMessage,*iEngine, KNullDesC));

        if (result == CWPBootstrap::EPinRequired)

            {

            CMsvEntry* entry = iSession->GetEntryL(iId);

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

            // Create a new device dialog if it is not there

            if( !iDevDialog )

              {                 

                iDevDialog = CHbDeviceDialogSymbian::NewL();

                LOGSTRING("CWPBioControl::AuthenticateL() iDevDialog is created");

              }

            CHbSymbianVariantMap* parameters = CHbSymbianVariantMap::NewL();

            CleanupStack::PushL(parameters);

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

                {

                // Add dialog key and dialog type to the parameters

                const TPtrC dialog (static_cast<const TUint16*>(keydialog.utf16()), keydialog.length());

                CHbSymbianVariant* dialogvariant = NULL;

                const TInt dialogID = EOmaCPPinDialog;

                dialogvariant = CHbSymbianVariant::NewL( &dialogID, CHbSymbianVariant::EInt );

                parameters->Add(dialog, dialogvariant );

                // Add retries value to the parameters                

                itries = i;

                const TPtrC ptrkeyparam1 (static_cast<const TUint16*>(keyparam1.utf16()), keyparam1.length());

                //Retries left after this attempt

                TInt retries = KPinRetries - itries;

                CHbSymbianVariant* retriesvariant = NULL;

                retriesvariant = CHbSymbianVariant::NewL( &retries, CHbSymbianVariant::EInt );

                parameters->Add(ptrkeyparam1, retriesvariant );

                if (iDevDialog && iIsDisplayingDialog)

                    {

                    LOGSTRING("[CWPBioControl] CWPBioControl::AuthenticateL updating the dialog");

                    iDevDialog->Update(*parameters);

                    }

                else if (iDevDialog && !iIsDisplayingDialog)

                    {

                    // Show the device dialog

                    iDevDialog->Show(KDeviceDialogType,*parameters, this);

                    iIsDisplayingDialog = ETrue;

                    // Wait for user response

                    TInt error = WaitUntilDeviceDialogClosed();

                    LOGSTRING2("WaitUntilDeviceDialogClosed err is %d", error);

                    User::LeaveIfError(error);                    

                        if(ireturnkey == EHbRSK)

                        {

                        iAuth = KAUTENTICATIONCANCEL;

                        CleanupStack::PopAndDestroy(parameters);

                        return false;

                        }

                    }

                }

            CleanupStack::PopAndDestroy(parameters);

            if (iDevDialog)

                {

                iDevDialog->Cancel();

                delete iDevDialog;

                iDevDialog = NULL;

                }

            if( !aMessage.Authenticated() && (itries == KPinRetries - 1)  )

                {

                 iMsg->autheticationFailure();

                 return false;

                }

            }

        }                

    if(!aMessage.Authenticated())

        {

        postAuthetication();        

        }

    else if(aMessage.Authenticated())

        {

        iAuth = KAUTENTICATIONSUCCESS;   

        }

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

    return true;    

  }

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

// CWPBioControl ::authenticationFailed

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

//

void CWPBioControl::authenticationFailed()

    {

    iAuth = KAUTENTICATIONFAILURE;    

    iSp->authenticationStatus();

    }

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

// CWPBioControl ::SaveMessageL

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

//

void CWPBioControl::SaveMessageL()

    {

    CMsvEntry* entry = iSession->GetEntryL(iId);

    CleanupStack::PushL( entry );

    CMsvStore* editStore = entry->EditStoreL();

    CleanupStack::PushL( editStore );

    iMessage->StoreL( *editStore );

    editStore->CommitL();

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

    }

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

// CWPBioControl ::CollectItemsL

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

//

EXPORT_C RPointerArray<CWPNameValue>* CWPBioControl::CollectItemsLC() const

    {

    RPointerArray<CWPNameValue>* array = new(ELeave) RPointerArray<CWPNameValue>;

    CleanupStack::PushL( TCleanupItem( Cleanup, array ) );

    TInt count( iEngine->ItemCount() );

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

    for( TInt index = 0; index < count; index++ )

        {

        const TDesC& text = iEngine->SummaryText( index );

        const TDesC& title = iEngine->SummaryTitle( index );

        CWPNameValue* pair = CWPNameValue::NewLC( title, text );

        User::LeaveIfError( array->Append( pair ) );

        CleanupStack::Pop( pair );

        }

    array->Sort( TLinearOrder<CWPNameValue>( CWPBioControl::Compare ) );

    return array;

    }

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

// CWPBioControl::Cleanup

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

//

void CWPBioControl::Cleanup( TAny* aAny )

    {

    RPointerArray<CWPNameValue>* array = reinterpret_cast<RPointerArray<CWPNameValue>*>( aAny );

    array->ResetAndDestroy();

    array->Close();

    delete array;

    }

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

// CWPBioControl::Compare

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

//

TInt CWPBioControl::Compare( const CWPNameValue& aItem1,

                             const CWPNameValue& aItem2 )

    {

    return aItem1.Name().Compare( aItem2.Name() );

    }

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

// CWPBioControl ::SaveSettingsL

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

//

void CWPBioControl::SaveSettingsL()

    {

    if( !iMessage->Saved())

    {

        DoSaveL();

        SaveSettingStatus();

    }

    else

    {    

        iMsg->saveSettingMessage();

    }

   }

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

// CWPBioControl ::SaveSettingStatus

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

//

void CWPBioControl::SaveSettingStatus()

    {

    iMessage->SetSaved( ETrue );

    SaveMessageL();

    }

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

// CWPBioControl ::DoSaveL

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

//

void CWPBioControl::DoSaveL()

    {

    TInt numSaved( 0 );

    CWPSaver* saver = new(ELeave) CWPSaver( *iEngine, EFalse );

    TBufC<KLENGTH> Value;

    TInt err( saver->ExecuteLD( numSaved, Value ) );

    if( err >= 0 )

        {

        // Check if any setting can be made default

        TBool setDefault( EFalse );

        TInt itemCount( iEngine->ItemCount() );

        for( TInt i( 0 ); i < itemCount && !setDefault; i++ )

            {

            if( iEngine->CanSetAsDefault( i ) )

                {

                setDefault = ETrue;

                }

            }

        // Ask the user if the saved settings should be 

        // made default.                     

        if( setDefault )

            {

            iMsg->setAsDefault();

            }

        }

    else

        {

         iMsg->settingNotSaved();

        }

    }

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

// CWPBioControl ::saveDefaultSetting

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

//

void CWPBioControl::saveDefaultSetting()

    {

     CWPSaver* setter = new(ELeave) CWPSaver( *iEngine, ETrue );

     TInt numSet( 0 );

     TBufC<KLENGTH> Value;

     TInt result = KErrNone;

     result = setter->ExecuteLD( numSet,Value );                            

     if (result)

     {

        iMsg->settingNotSaved();

     }

    }

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

// CWPBioControl ::SetCenrepKey

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

//

void CWPBioControl::SetCenrepKeyL(const TDesC8& aValue)

    {

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

    CRepository* rep= NULL;

    TInt errorStatus = KErrNone;

    TRAPD( errVal, rep = CRepository::NewL( KCRUidOMAProvisioningLV ))

    ;

    if (errVal == KErrNone)

        {

        errorStatus = rep->Set(KOMAProvOriginatorContent, aValue);