/*

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

// CONSTANTS

/// 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(CMsvSession* aSession,TMsvId aId)

    {

    }

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

// CWPBioControl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

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

    {

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

    FeatureManager::InitializeLibL();

    iSession = aSession;

    iId = aId;

    iEngine = CWPEngine::NewL();

    RestoreMsgL();

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

    }

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

// CWPBioControl::NewL

// Two-phased constructor.

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

//

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

     {

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

    CleanupStack::PushL( self );

    self->ConstructL(aSession,aId);

    CleanupStack::Pop();

    return self;

    }

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

// CWPBioControl::returnEngine

// Return CWPEngine pointer

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

//    

EXPORT_C CWPEngine* CWPBioControl::returnEngine()

    {

    return iEngine;

    }

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

// Destructor

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

CWPBioControl::~CWPBioControl()

    {

    delete iEngine;

    delete iMessage;

    FeatureManager::UnInitializeLib();

    }

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

// CWPBioControl ::RestoreMsgL

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

//

void CWPBioControl::RestoreMsgL()

    {                    

    CMsvEntry* entry = iSession->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

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

    if( result == KErrCorrupt )

        {

        //result = KErrMsgBioMessageNotValid;

        }

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

    User::LeaveIfError( result );

    TBool preAuthenticated( iMessage->Authenticated() );

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

    AuthenticateL( *iMessage );

    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 

        }

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

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

    }

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

// CWPBioControl ::AuthenticateL

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

//

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

             }

        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 = iSession->GetEntryL(iId);

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

            TInt ipin = 1234;

            TBuf<KMaxPinSize> pin;

            pin.AppendNum(ipin);

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

            CleanupStack::PopAndDestroy( bootstrap );

          }

      }

    if (aMessage.Authenticated() )

        {

        //update Cenrep key

        TBuf8<100> orig;

        orig.Copy(aMessage.Originator());

        TRAPD(err, SetCenrepKeyL(orig));

        User::LeaveIfError(err);

        }

    }

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

// 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 ::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);

        }

    else

        {

        errorStatus = errVal;

        }

    if (rep)

        {

        delete rep;

        }

    if (errorStatus != KErrNone)

        {

        User::Leave(errorStatus);

        }

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

    }

//  End of File