/*

* Copyright (c) 2002-2006 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:  Reads a provisioning document from a SIM/WIM card

*

*/

// INCLUDE FILES

#include	"CWPProvisioningSC.h"

#include	<eikdll.h>

#include	<e32std.h>

#include	<e32svr.h>

#include	<e32base.h>

#include	<CWPEngine.h>

#include	<AknGlobalNote.h> 

#include	<ProvisioningSC.rsg>

#include	<WPAdapterUtil.h>

#include	"MWPPhone.h"

#include	"CWPPushMessage.h"

#include	"CWPBootstrap.h"

#include	"CWPImsiDbHandler.h"

#include	"CWPWimHandler.h"

#include	"CWPBioMsgHandler.h"

#include	"WPPhoneFactory.h"

#include	"ProvisioningDebug.h"

#include	"WPProvScPaths.h"

#include	<ProvSC.h>

const TInt KPhoneRetryCount = 7;

const TInt KPhoneRetryTimeout = 100000; 

_LIT( KProvisioningSCThread, "ProvisioningSC" );

// LOCAL FUNCTION PROTOTYPES

// Initializes the server.

LOCAL_C void InitProvScL();

// ==================== LOCAL FUNCTIONS ====================

LOCAL_C void InitProvScL()

	{

	FLOG( _L( "[ProvisioningSC] InitProvScL" ) );

__UHEAP_MARK;

	TBool acInstalled( EFalse );

    // Scheduler exists before this point only in test code:

	if( CActiveScheduler::Current()==NULL )

		{

		CActiveScheduler* ac = new (ELeave) CActiveScheduler;

		CleanupStack::PushL( ac ) ;

		CActiveScheduler::Install( ac );

		acInstalled = ETrue;

		}

	CWPProvisioningSC* reader = CWPProvisioningSC::NewLC();

      RProcess::Rendezvous(KErrNone);

	if ( reader->ReadFile() )  

		{

        FLOG( _L( "[ProvisioningSC] InitProvScL starting sched" ) );

		CActiveScheduler::Start();  // start only if request issued

		FLOG( _L( "[ProvisioningSC] InitProvScL, after shed start, continuing" ) );

		}

	CleanupStack::PopAndDestroy(  ); // reader

	if( acInstalled )

		{

		FLOG( _L( "[ProvisioningSC] InitProvScL acinstalled - uninstalling." ) );

		CActiveScheduler::Install( NULL ); // uninstall

		CleanupStack::PopAndDestroy(); // ac

		}

__UHEAP_MARKEND;

	}

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

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

// CWPProvisioningSC::CWPProvisioningSC

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CWPProvisioningSC::CWPProvisioningSC()

    {

    }

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

// CWPProvisioningSC::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWPProvisioningSC::ConstructL()

    {

    User::RenameThread( KProvisioningSCThread );

	iImsiHandler = CWPImsiDbHandler::NewL(); // 1

	TBool isOld = ProcessImsiL( iPhoneImsi ); 

	if( !isOld )

		{

		FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ConstructL new imsi" ) );

		iWimHandler = CWPWimHandler::NewL( *this );

		FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ConstructL StoreImsi" ) );

		iImsiHandler->StoreImsiL( iPhoneImsi );

		}

    }

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

// CWPProvisioningSC::NewL

// Two-phased constructor.

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

//

CWPProvisioningSC* CWPProvisioningSC::NewL()

    {

	CWPProvisioningSC* self = CWPProvisioningSC::NewLC();

	CleanupStack::Pop();

    return self;

    }

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

// CWPProvisioningSC::NewL

// Two-phased constructor.

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

//

CWPProvisioningSC* CWPProvisioningSC::NewLC()

    {

    CWPProvisioningSC* self = new( ELeave ) CWPProvisioningSC;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CWPProvisioningSC::Destructor

// 

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

//

CWPProvisioningSC::~CWPProvisioningSC()

    {

	delete iProvisioningDoc;

	delete iImsiNumbers;

	delete iWimHandler;

	delete iImsiHandler;

    }

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

// CWPProvisioningSC::ReadCompletedL

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

//

void CWPProvisioningSC::ReadCompletedL()

	{

	FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ReadCompletedL" ) );

	iProvisioningDoc = iWimHandler->DocL( );

	TRAPD( err, StoreDocL( *iProvisioningDoc ));

	if( err == KErrDiskFull || err == KErrNoMemory  )

		{

		ShowMemoryLowNoteL();

		}

	FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ReadCompletedL stopping sched" ) );

	CActiveScheduler::Stop();

	FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ReadCompletedL sched stopped" ) );

	}	

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

// CWPProvisioningSC::ReadCancelledL

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

//

void CWPProvisioningSC::ReadCancelledL()

	{

	if( iWimHandler )

		{

		CActiveScheduler::Stop();

		}

	}

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

// CWPProvisioningSC::ReadErrorL

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

//

void CWPProvisioningSC::ReadErrorL()

	{

	if( iWimHandler )

		{

		CActiveScheduler::Stop();

		}

	}

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

// CWPProvisioningSC::ProcessImsiL

//

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

//

TBool CWPProvisioningSC::ProcessImsiL( TDes& aPhoneImsi )

	{

	TBool isOldImsi( ETrue );

	if( iImsiHandler )

		{

		FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ProcessImsiL" ) );

		TInt err( KErrNotFound );

		MWPPhone* phone = NULL; 

		for ( TInt j = 0 ; j < KPhoneRetryCount ; j++ )

			{

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

			// note: phone not in cleanupstack

			if ( err == KErrNone )

				{

				aPhoneImsi.Copy( phone->SubscriberId() ); // store imsi

				delete phone; 

				phone = NULL;

				break;

				}

			User::After( KPhoneRetryTimeout );

			}

		User::LeaveIfError( err );

		FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ProcessImsiL imsiexistsL?" ) );

		isOldImsi = iImsiHandler->ImsiExistsL( aPhoneImsi );

		FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ProcessImsiL imsiexistsL ok" ) );

		}

	return isOldImsi;

	}

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

// CWPProvisioningSC::ReadFileL

//

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

//

TBool CWPProvisioningSC::ReadFile()

	{

    FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ReadFile" ) );	

	if( iWimHandler )

		{

		FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ReadFile wimhandler" ) );

		iWimHandler->ReadProvFile( EBootStrap );

		return ETrue;

		}

	else

		{

		FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::ReadFile wimhandler null" ) );

		return EFalse;

		}

	}

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

// CWPProvisioningSC::ShowMemoryLowNoteL

//

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

//

void CWPProvisioningSC::ShowMemoryLowNoteL()

	{

	TFileName fileName;

	#ifndef __WINS__

	fileName = RProcess().FileName();

	#else

	Dll::FileName( fileName );

	#endif

	HBufC* memLowText = WPAdapterUtil::ReadHBufCL( fileName,

												KWPProvSCName,

												R_TEXT_MEM_SUCS );

    CleanupStack::PushL( memLowText );  // 1

	CAknGlobalNote* note = CAknGlobalNote::NewLC();  // 2

	note->ShowNoteL( EAknGlobalInformationNote, *memLowText );

	CleanupStack::PopAndDestroy( 2 ); // note, memLowText

	}

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

// CWPProvisioningSC::StoreDocL

//

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

//

void CWPProvisioningSC::StoreDocL( TDesC8& aProvDoc )

	{

    FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL" ) );

    HBufC8* convert = aProvDoc.Alloc();

    TPtr8 ptrBuffer( convert->Des() );

	while ( ( ptrBuffer[ptrBuffer.Length()-1 ] == 0xFF ) && (ptrBuffer.Length() > 1 ) )

	    {

		FTRACE(RDebug::Print(_L("[ProvisioningSC] CWPProvisioningSC::StoreDocL ... deleting (%d)"), (ptrBuffer.Length()-1)));

		ptrBuffer.Delete( ( ptrBuffer.Length()-1 ) , 1 );

	    }

	FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL cleanup done" ) );

	aProvDoc = *convert;

    delete convert;

    #ifdef _DEBUG

    FHex(aProvDoc);

    #endif

	CWPBioMsgHandler* msgHandler = CWPBioMsgHandler::NewLC(); // 1

	CWPPushMessage* msg = msgHandler->CreateMessageLC( aProvDoc ); // 2

	msg->SetAuthenticated( ETrue );

    // 0. read the message into the engine

    CWPEngine* engine = CWPEngine::NewLC();  // 3

	FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL2" ) );

	#ifdef _DEBUG

	FHex(msg->Body() );

	#endif

    engine->ImportDocumentL( msg->Body() );

	FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL3" ) );

	engine->PopulateL();

	// 1. process bootstrap

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

    CleanupStack::PushL( bootstrap );// 4

	FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL4" ) );

    CWPBootstrap::TBootstrapResult bootstrapResult( 

        bootstrap->BootstrapL( *msg, *engine, KNullDesC ) );

    CleanupStack::PopAndDestroy(); // bootstrap, 4 

	TBool haveSettings( engine->ItemCount() > 0 );

	// 2.A Does the message contain bootstrap?

	switch( bootstrapResult )

		{

	case CWPBootstrap::ESucceeded:

			// fallthrough

		case  CWPBootstrap::EBootstrapExists:

		{

		if( haveSettings ) 

			{

			FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL5" ) );

			msgHandler->StoreMessageL( *msg );

			FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL6" ) );

			}

		else

			{

			// no other settings than the TPS, store a note into inbox

			// but first check that the TPS is not already defined

			if(!( bootstrapResult == CWPBootstrap::EBootstrapExists ) )

				{

				FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL8" ) );

				msgHandler->StoreMessageL( R_TEXT_PROV_SUCS, *msg );

				FLOG( _L( "[ProvisioningSC] CWPProvisioningSC::StoreDocL9" ) );;

				}

			}

		break;

		}

		// 2.B No bootstrap

	case CWPBootstrap::ENoBootstrap:

		{	

		if( haveSettings )

			{

			// 2.B.I store settings into inbox

			msgHandler->StoreMessageL( *msg );

			}

			// 2.B.II, no boostrap, no settings -> just ignore message.

		break;

		}	

	default:

		{

		break;

		}

	} // switch

	CleanupStack::PopAndDestroy( 3 ); // msg, handler, engine

	}

// ================= OTHER EXPORTED FUNCTIONS ==============

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

// E32Main implements the executable entry function.

// Note that because the target type of the ProvSC module

// is EXEDLL, the entry point has different signature depending

// on the build platform.

// Creates a cleanup stack and runs the server.

// Returns: Zero.

#if defined (__WINS__)

IMPORT_C TInt WinsMain();

EXPORT_C TInt WinsMain()

#else  //if defined(__EPOC32__)

GLDEF_C TInt E32Main()

#endif

    {

	CTrapCleanup* cleanup = CTrapCleanup::New();

    TRAPD( error, InitProvScL() );

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

	delete cleanup;

	return KErrNone; 

    }

//  End of File