* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies). 

* Description:  This file contains the implementation of PolicyEngineUI

// INCLUDE FILES

#include "PolicyEngineUi.h"

#include "debug.h"

#include "policyengineui.hrh"

#include <policyengineuidlgs.rsg>

#include <bautils.h>

#include <eikenv.h>

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <eikprogi.h>

#include <aknnotewrappers.h>

#include <aknmessagequerydialog.h>

#include <data_caging_path_literals.hrh>

#include "SyncService.h"

#include <implementationproxy.h>

_LIT( KCUIResourceFileName, "PolicyEngineUIDlgs.rsc" );

const TUid KUidPolicyEngineUi = { 0x10207817 };

const TUid KScreenOutputChannel = { 0x0000781F };

LOCAL_C void CreateNotifiersL( CArrayPtrFlat<MEikSrvNotifierBase2>* aNotifiers );

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

// CArrayPtr<MEikSrvNotifierBase2>* NotifierArray()

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

//

LOCAL_C void CreateNotifiersL( CArrayPtrFlat<MEikSrvNotifierBase2>* aNotifiers )

{

    MEikSrvNotifierBase2 *policyEngineNotifier = CPolicyEngineNotifier::NewL();

    CleanupStack::PushL( policyEngineNotifier );

    aNotifiers->AppendL( policyEngineNotifier );

    CleanupStack::Pop( policyEngineNotifier ); // serNotify

	RDEBUG("PolicyEngineUI notifier created!");

}

CArrayPtr<MEikSrvNotifierBase2>* NotifierArray()

    { 

    CArrayPtrFlat<MEikSrvNotifierBase2>* array =

    new CArrayPtrFlat<MEikSrvNotifierBase2>( 1 );

    if (array)

        {

        TRAPD( err, CreateNotifiersL( array ) );

        if (err != KErrNone)

            {

            delete array;

            array = NULL;

            }

        }

    return array;

const TImplementationProxy ImplementationTable[] = { {{0x10207817},(TProxyNewLPtr)NotifierArray} };

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	RDEBUG("PolicyEngineUI notifier detected!");

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy) ;

	return ImplementationTable;

	}

CPolicyEngineNotifier::CPolicyEngineNotifier()

	{

	}

CPolicyEngineNotifier::~CPolicyEngineNotifier()

	{

	//delete and close policy engine ui

	delete iPolicyEngineUi;	

	}

CPolicyEngineNotifier* CPolicyEngineNotifier::NewL()

	{

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

	CleanupStack::PushL( self);

	self->ConstructL();	

	CleanupStack::Pop();

	return self;

	}

void CPolicyEngineNotifier::ConstructL()

	{

	}

void CPolicyEngineNotifier::Release()

	{

	delete this;	

	}

CPolicyEngineNotifier::TNotifierInfo CPolicyEngineNotifier::RegisterL()

	{

	//Registration info

    iInfo.iUid = KUidPolicyEngineUi;

    iInfo.iPriority = ENotifierPriorityHigh;

	iInfo.iChannel = KScreenOutputChannel;	

	return iInfo;

	}

CPolicyEngineNotifier::TNotifierInfo CPolicyEngineNotifier::Info() const

	{

	//Registration info

	return iInfo;

	}

TPtrC8 CPolicyEngineNotifier::StartL(const TDesC8& /*aBuffer*/)

	{

	return KNullDesC8().Ptr();

	}

void CPolicyEngineNotifier::Complete( TUserResponse aResponse)

	{

	RDEBUG("CPolicyEngineNotifier::Complete");

	//Write return value to message and compeltes it

	if ( aResponse == EUserAccept )

		{

		iMessage.Write( iReplySlot, KUserAcceptMark, 0);	

		}

	else

		{

		iMessage.Write( iReplySlot, KUserDenyMark, 0);	

		}

    iManager->CancelNotifier( iInfo.iUid );   // Notify framework we've done

	iMessage.Complete( KErrNone);

	}

void CPolicyEngineNotifier::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	RDEBUG("CPolicyEngineNotifier::StartL!");

	TInt index = aBuffer.Locate( KDelimeterChar);

	if ( index != KErrNotFound && !iPolicyEngineUi)

		{	

		//decode name and fingerprint from message

		TPtrC8 name = aBuffer.Left( index);

		TPtrC8 fingerPrint = aBuffer.Mid( index + 1);

		iReplySlot = aReplySlot;

		iMessage = aMessage;

		//Show policy engine ui dialogs

		iPolicyEngineUi = CPolicyEngineUi::NewL();

		iPolicyEngineUi->ActivateL( name, fingerPrint, this);

		}

	else

		{

		Complete( EUserDeny);

		}

	}

void CPolicyEngineNotifier::Cancel()

	{

	RDEBUG("CPolicyEngineNotifier::Cancel!");

	//Delete policy engine ui

	delete iPolicyEngineUi;

	iPolicyEngineUi = 0;

	}

TPtrC8 CPolicyEngineNotifier::UpdateL(const TDesC8& /*aBuffer*/)

	{

	return KNullDesC8().Ptr();

	}

CPolicyEngineUi::CPolicyEngineUi()

	: CActive( EPriorityStandard)

    {  

void CPolicyEngineUi::ConstructL()

    {

	RDEBUG("CPolicyEngineUi::ConstructL!");

    //get pointer to CEikonEnv

	iCoeEnv = CEikonEnv::Static();    

    if ( !iCoeEnv )

    	{

		RDEBUG("Policy engine ui: CoeEnv not found!");

        User::Leave( KErrGeneral );        

    	}

	//Open resource file

    TFileName fileName;

    fileName.Zero();

    TFileName drivePath;

    Dll::FileName( drivePath );

    fileName.Append( TParsePtrC( drivePath ).Drive() );

    fileName.Append( KDC_RESOURCE_FILES_DIR );

    fileName.Append( KCUIResourceFileName );   

    BaflUtils::NearestLanguageFile( iCoeEnv->FsSession(), fileName );

	//handle to resource file

    iResourceFileOffset = iCoeEnv->AddResourceFileL( fileName );

	RDEBUG("Policy engine ui resources loaded!");

 	}

CPolicyEngineUi* CPolicyEngineUi::NewL()

	{

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self; 

	}

CPolicyEngineUi::~CPolicyEngineUi()

	{

	RDEBUG("CPolicyEngineUi::~CPolicyEngineUi()");

    // Close non-modal dialogs

    if( iResourceFileOffset )

    	{

        iCoeEnv->DeleteResourceFile( iResourceFileOffset );

    	}

	delete iCorporate;

	delete iRandomPart;

	}

void CPolicyEngineUi::ActivateL( const TDesC8& aCorporate, const TDesC8& aRandomPart, CPolicyEngineNotifier* aNotifier)

	{

	RDEBUG("CPolicyEngineUi::ActivateL");

	//reference to notifier (for message completion)

	iNotifier = aNotifier;

	//allocate new space for parameters and save them

	delete iCorporate;

	iCorporate = NULL;

	delete iRandomPart;

	iRandomPart = NULL;

	iCorporate = HBufC::NewL( aCorporate.Length());

	iRandomPart = HBufC::NewL( aRandomPart.Length());

	iCorporate->Des().Copy( aCorporate);

	iRandomPart->Des().Copy( aRandomPart);	

	//add active object to active scheduler and set object active

	CActiveScheduler::Add( this);

	SetActive();

	//complete request....

	TRequestStatus * status = &iStatus;

	User::RequestComplete( status, KErrNone);	

	}

void CPolicyEngineUi::RunL()

	{

	RDEBUG("CPolicyEngineUi::RunL()");

	//in state ERemove user has already accepted query

	if ( ERemove == iState )

		{

		//show info, remove from scheduler

		ShowDialogL( ERemove);

		Deque();

		iNotifier->Complete( EUserAccept);

		return;		

		}

	if ( EDenied == iState )

		{

		//show info, remove from scheduler

		ShowDialogL( EDenied);

		Deque();

		iNotifier->Complete( EUserDeny);

		return;		

		}

	//Control dialog

	if ( EUserAccept == ShowDialogL( (TDialog) iState))

		{

		//if user cancel dialog, show deny-dialog and return

		iState = iState + 1;

		}

	else

		{

		//user press cancel -> state = EDenied

		iState = EDenied;

		}

	//set active and complete message

	SetActive();

	TRequestStatus * status = &iStatus;

	User::RequestComplete( status, KErrNone);

	}

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

// CPolicyEngineUi::RunError

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

TInt CPolicyEngineUi::RunError ( TInt /*aError*/ )

    {

       return KErrNone;

    }	

void CPolicyEngineUi::DoCancel()

	{

	}

CPolicyEngineUi::TDlgResp CPolicyEngineUi::ShowConfirmationQueryL( 

	const TDesC& aText, const TBool& aWithCancel)

	{

	//create dialog

    CAknQueryDialog* note = 

        CAknQueryDialog::NewL( CAknQueryDialog::EConfirmationTone );

	//select correct text resource 					 

	TInt resource = R_POLICYENGINEUI_CONFIRMATION_QUERY;

	if ( !aWithCancel )

		{

		resource = R_POLICYENGINEUI_CONFIRMATION;

		}			   

	//execute dialog, dialog contains self destruction			 

    TInt response = note->ExecuteLD( resource, aText );

	if ( response )

		{

		return EOkResp;

		}

	return ECancelResp;

	}

CPolicyEngineUi::TDlgResp CPolicyEngineUi::DataQueryL( const TDesC& aText, TDes& aInput )

	{

	//Create dialog with reference to input descriptor

	CAknTextQueryDialog* dlg = 

		CAknTextQueryDialog::NewL( aInput, CAknQueryDialog::ENoTone);

	//set prompt

	CleanupStack::PushL( dlg);

	dlg->SetPromptL( aText);

	CleanupStack::Pop();

	//execute dialog, dialog contains self destruction			 

	TInt response = dlg->ExecuteLD( R_POLICYENGINEUI_DATA_QUERY);

	if ( response )

		{

		return EOkResp;

		}

	return ECancelResp;

	}

TInt CPolicyEngineUi::ShowDialogL( const TDialog& aDialog)

	{

	TInt response = EUserDeny;

	//select correct dialog

	switch ( aDialog)

		{

		case EControl : 

			{

			response = ShowPossessionMessageQueryL();

			break;

			}

		case ERemove:

			{

			//load resource

		    HBufC* displayString = StringLoader::LoadLC( R_POLICYENGINEUI_TRUST_ESTABLISHED );

			TInt length1 = displayString->Length();

			HBufC16* trustString = HBufC16::NewLC ( length1  );

			TPtr bufPtr = trustString -> Des();

			bufPtr.Append (*displayString);

			// Hide background connecting note

			CSyncService *syncService =

                            CSyncService::NewL(NULL, KDevManServiceStart);

                    if (syncService)

                        {

                        syncService->EnableProgressNoteL(EFalse);

                        }

                    delete syncService;

			response = ShowConfirmationQueryL( *trustString, EFalse);

			CleanupStack::PopAndDestroy();

			CleanupStack::PopAndDestroy();

			break;

			}

		case EDenied:

			{

			//load resource

			TBuf<100> array(*iCorporate);

		  HBufC* displayString = StringLoader::LoadLC( R_POLICYENGINEUI_DENIED_NOTE, array);

			//show dialog and get response

			response = ShowConfirmationQueryL( *displayString, EFalse);

			//delete resource

			CleanupStack::PopAndDestroy();

			break;

			}		

		case EUnMatch:

			{

			//load resource

		    HBufC* displayString = StringLoader::LoadLC( R_POLICYENGINEUI_UNMATCH_NOTE);

			//show dialog and get response

			response = ShowConfirmationQueryL( *displayString, ETrue);

			//delete resource

			CleanupStack::PopAndDestroy();

			break;

			}

		case EQuestion:

			{

			//question note prompt

			TBuf<100> array(*iCorporate);

    		HBufC* displayString = StringLoader::LoadLC( R_POLICYENGINEUI_QUESTION_NOTE,array);

			TBuf<RANDOM_PART_MAX_SIZE> input;

			TBool ready = EFalse;

			//until cancel pressed or valid user gives valid certificate part

			while ( !ready)

				{

				//data query

				CPolicyEngineUi::TDlgResp resp = DataQueryL( *displayString, input);

				if ( resp == EUserAccept )

					{

					if ( input.CompareF( *iRandomPart) != 0)

						{

						//if user input doesn't match

						if ( EUserDeny == ShowDialogL( EUnMatch))

							{

							//if user cancel dialog, show deny-dialog and return

							response = EUserDeny;

							break;

							}			

						}

					else

						{

						response = EUserAccept;