/*

* Copyright (c) 2007 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:  Location Centre Server object.

*

*/

// SYSTEM INCLUDES

#include <apgcli.h>

#include <pathinfo.h>

// USER INCLUDES

#include "lcregistry.h"

#include "lcregistrationparser.h"

#include "lcregistryupdate.h"

#include "lcregistrationupdatenotifier.h"

#include "lcregapporder.h"

#include "lcregistryobserver.h"

#include "lcregappinfo.h"

#include "lcregappstore.h"

#include "lcdebug.h"

// CONSTANT DEFINTIONS

//Forward declaration. Function for sorted ordering of appinfo array

static TInt PositionDescOrdering( const CLcRegAppInfo& aAppInfo1, 

			  				   	  const CLcRegAppInfo& aAppInfo2 );

// ----- Member funtions for CLcRegistry ---------------------------------

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

// CLcRegistry::CLcRegistry

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

//

CLcRegistry::CLcRegistry( MLcRegistryObserver& aRegistryObserver )

	:CActive(EPriorityStandard),

	iRegistryObserver( aRegistryObserver )

    {

    // C++ Default constructor. No allocations or functions which can Leave

    // should be called from here.Initiallize all the variable here

    }

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

// CLcRegistry::~CLcRegistry

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

//

CLcRegistry::~CLcRegistry()

    {

	Cancel();

    // C++ Destructor. Free all resources associated with this class.

	delete iLcRegUpdate;

	delete iRegAppStore;

	delete iLcRegAppOrder;

	//close the file server session.

	iFs.Close();

	// free filename array memory

	iFileNameArry.Reset();		

	iFileNameArry.Close();

	//delete all items from the appinfo array.

	iAppInfoArray.ResetAndDestroy();

	iAppInfoArray.Close();

	iAppInfoNewArray.ResetAndDestroy();

	iAppInfoNewArray.Close();

    }

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

// CLcRegistry* CLcRegistry::NewL

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

//

CLcRegistry* CLcRegistry::NewL( MLcRegistryObserver& aRegistryObserver )

    {

    CLcRegistry* self = NewLC( aRegistryObserver );

    CleanupStack::Pop( self );

    return self;         

    }

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

// CLcRegistry* CLcRegistry::NewLC

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

//

CLcRegistry* CLcRegistry::NewLC( MLcRegistryObserver& aRegistryObserver )

    {

    // Symbian Two phased constructor. Leaves the object on the Clean-up

    // stack.

    CLcRegistry* self = new ( ELeave )CLcRegistry( aRegistryObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;         

    }

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

// void CLcRegistry::ConstructL

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

//

void CLcRegistry::ConstructL()

    {

    // connect to file server

    // and pass this session to all the class required.

	User::LeaveIfError(iFs.Connect());

    // creation of dynamic registration notifier object

    iLcRegUpdate	= CLcRegistryUpdate::NewL( *this, iFs);

    // creation of private info object

    iRegAppStore	= CLcRegAppStore::NewL(iFs); 

    // creation of application order settings object

    iLcRegAppOrder	= CLcRegAppOrder::NewL( *iRegAppStore );

	// reset the new applist array count here

	iAppInfoNewArray.Reset();    

	/* Now Check if any update needed to that list.

	 * To do that start all the system drive scan and collect

	 * all the registered file names

	 */     

	iRegistryHasToUpdate = EFalse;

	// registered for notification in private directory from file server

    iLcRegUpdate->StartFileNotifation();

	// Add it to Active scheduler

    CActiveScheduler::Add( this );    

    // issue the request to active scheduker

    CheckForUpdationL();

    }  

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

// void CLcRegistry::CheckForUpdationL()

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

//

void CLcRegistry::CheckForUpdationL()

    {

    // inform registry engine that registration process is under updation

    iRegistryObserver.RegistryUnderUpdation();

    // set the file count to zero

    iregFileCount = 0;

    // Scan all the drives and get all the registered file names

	ScanDrivesAndGetFileNameL();

    DEBUG3("Updated File list : %d", iFileNameArry.Count(), 0, 0 );

	// issue a request to active scheduler

	IssueRequest();

    }  

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

// void CLcRegistry::IssueRequest

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

//

void CLcRegistry::IssueRequest()

    {

	if(!IsActive())

		{

		SetActive();

		TRequestStatus *status = &iStatus;

		User::RequestComplete(status,KErrNone);			

		}

    }  

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

// TInt CLcRegistry::GetAllRegisteredAppsList

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

//

TInt CLcRegistry::GetAllRegisteredAppsList( RPointerArray<CLcAppInfo>& appInfoArray )

    {

    //DEBUG( "+ CLcRegistry::GetAllRegisteredAppsList");

    TInt error = KErrNone;

    if( iAppInfoArray.Count() <= 0 )

	    {

	    error = KErrNotFound;	

	    }

    else

	    {

	    for(TInt i = 0; i < iAppInfoArray.Count(); i++)

		    {

		    // check wheather application is present

		    // append only present application

		    if( iAppInfoArray[i]->IsAppPresent() )

			    {

				error = appInfoArray.Append( iAppInfoArray[i] );

				if ( error )

    				{

    				break;

    				}

			    }

		    }

	    }	    

	DEBUG3("Get Registered Apps : %d", appInfoArray.Count(), 0, 0 );

    //DEBUG( "- CLcRegistry::GetAllRegisteredAppsList");    

	return error;

    }  

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

// TInt CLcRegistry::GetApplicationInfo

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

//

TInt CLcRegistry::GetApplicationInfo( const TDesC& 	aAppUid,

									  CLcBasicAppInfo*&	aLcRegAppInfo )   

	{

    //DEBUG( "+ CLcRegistry::GetApplicationInfo");

	for(TInt i = 0; i< iAppInfoArray.Count(); i++)

		{

		if( !aAppUid.Compare( iAppInfoArray[i]->Id()) &&

		    iAppInfoArray[i]->IsAppPresent())		

			{

			aLcRegAppInfo = iAppInfoArray[i];

			return KErrNone;	

			}

		}

    //DEBUG( "- CLcRegistry::GetApplicationInfo");

	return KErrNotFound;		

	}

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

// void CLcRegistry::HandleDynamicRegistrationL

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

//

void CLcRegistry::HandleDynamicRegistrationL()

    {

    DEBUG("+CLcRegistry::HandleDynamicRegistrationL");

    iRegistryHasToUpdate = ETrue;

	CheckForUpdationL();

    }  

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

// void CLcService::ScanDrivesAndGetFileNameL

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

//

void CLcRegistry::ScanDrivesAndGetFileNameL()

    {

    DEBUG( "+ CLcRegistry::ScanDrivesAndGetFileNameL");    

    iFileNameArry.Reset();

	//declare the directory to be scan through

	_LIT(KPriDirName, ":\\private\\10283138\\import\\" );

    TFileName srcDirName( KPriDirName );

	TDriveList dirList;

    if(iFs.DriveList( dirList ) != KErrNone)

	    {

	    return;	

	    }

    TBuf<KMaxFileName> rootDir;

    //creating the CDirscan object

    CDirScan* scanner = CDirScan::NewLC(iFs); 

    TChar driveLetter = '?';

    TDriveInfo info;

    TInt error;

    //Scan for all drives in the system 

    TInt driveListSize = dirList.Length();

    for(TInt dir(0); dir < driveListSize; dir++)

        {

        error = iFs.Drive(info, dir);

        if  ((error == KErrNone) && 

            (dirList[dir] && info.iType != EMediaNotPresent))

            {

            RFs::DriveToChar(dir, driveLetter);

            rootDir.Zero();//Clear the previous contents                  

            rootDir.Append(driveLetter);

            rootDir.Append( srcDirName );

			CDir *currentDir = NULL;

			// Go through the files only

			scanner->SetScanDataL( rootDir, KEntryAttNormal, ESortNone );

			TRAP( error, scanner->NextL( currentDir ));

			if( error )

				{

				continue;

				}

			TInt entryCount = currentDir->Count();           

		    while(entryCount--)

        		{

			    TBuf<KMaxFileName> lookup;

				TEntry entry=( *currentDir )[entryCount];

				//Clear the previous values

				lookup.Zero();

				//Append next one

				lookup.Append(scanner->FullPath());

				lookup.Append(entry.iName);

				//Store it in for future reference

				iFileNameArry.Append(lookup);

        		}

			delete currentDir;					

            }

        }

    CleanupStack::PopAndDestroy( scanner );

    DEBUG( "- CLcRegistry::ScanDrivesAndGetFileNameL");     

    }  

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

// CLcRegistry::RunL

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

//

void CLcRegistry::RunL()

    {

	TUint mmcId 	= 0;

	// This check is for if some update events come

	// during registration updation going on.

	if( iRegistryHasToUpdate )

		{

		DEBUG( "Dynamic notification recived");

		// Add all the appinfo to current list from new created list

		for( TInt i = 0; i < iAppInfoNewArray.Count(); i++ )

			{

			User::LeaveIfError( iAppInfoArray.Append( iAppInfoNewArray[i] ));

			}

		iAppInfoNewArray.Reset();		

		// end of loop set the flag as EFalse			

		iRegistryHasToUpdate = EFalse;

		DEBUG( "Notify execute");

		IssueRequest();

		}

	else

		{

		CLcRegAppInfo* regAppInfo = NULL;				

		if( iregFileCount < iFileNameArry.Count() )

			{

			// Check wheather registration file name is present in the

			// old registered list.If not then add as a new registration service

			TBool lResult = DoesApplicationExists( iFileNameArry[ iregFileCount ],

												   regAppInfo );

			if ( lResult )

				{

				// Check if the Application suffered an Upgrade. If its an upgrade

				// then its equivalent to a new installation.

					{

					// Remove the element from the Old array

					TInt index = iAppInfoArray.Find( regAppInfo );

					CLcRegAppInfo* info = iAppInfoArray[index];

					iAppInfoArray.Remove( index );

					delete info;

					// Parse new registration info validate and append it to list

					TRAPD( err, regAppInfo = 

									CreateAppRegInfoL(iFileNameArry[ iregFileCount ]));

					if( !err )

						{

						CleanupStack::PushL( regAppInfo );

						InsertAppRegInfoL( regAppInfo );

						CleanupStack::Pop( regAppInfo );

						}

					iregFileCount++;

					IssueRequest();				

					}

				else 

					{

					// Check and Set the Present status of the Application

					if( !regAppInfo->IsAppPresent() && 

						!GetMmcId( mmcId ) && 

						!mmcId == regAppInfo->MmcId())

						{

						// This condition is only when the Application was registered

						// prior to this and was on an MMC which was not mounted

						regAppInfo->SetFilePresenceStatus(ETrue);

						}

					// Remove the element from the Old array

					TInt index = iAppInfoArray.Find( regAppInfo );

					iAppInfoArray.Remove( index );

					// push the object to cleanup stack before calling 

					// InsertAppRegInfoL.

					CleanupStack::PushL( regAppInfo );

					InsertAppRegInfoL( regAppInfo );

					CleanupStack::Pop( regAppInfo );

					iregFileCount++;

					IssueRequest();					

					}				

				}

			else

				{

				// Parse new registration info validate and append it to list

				TRAPD( err, regAppInfo = 

								CreateAppRegInfoL( iFileNameArry[ iregFileCount ] ));

				if( !err )

					{

					CleanupStack::PushL( regAppInfo );

					InsertAppRegInfoL( regAppInfo );

					CleanupStack::Pop( regAppInfo );

					}

				iregFileCount++;

				IssueRequest();			

				}			

			}

		else

			{

			// After completing if part if there is any application present 

			// in the old array then check those application for absent or removal case.

	    	if( iAppInfoArray.Count() > 0 )

		    	{

				//Get current MMC id.

				if( GetMmcId( mmcId ) )

					{

					// Check for all Absent applications

					while( iAppInfoArray.Count())

						{

						regAppInfo = iAppInfoArray[0];

						iAppInfoArray.Remove( 0 );

						if( regAppInfo->MmcId() != mmcId )

							{

							regAppInfo->SetFilePresenceStatus(EFalse);

							CleanupStack::PushL( regAppInfo );

							InsertAppRegInfoL( regAppInfo );

							CleanupStack::Pop( regAppInfo );

							}

						else

							{							

							iLcRegAppOrder->RemoveArrayL( regAppInfo->Id() );

							delete regAppInfo;

							}							

						}

					}

				// Check for all de-registered applications

				while( iAppInfoArray.Count())

					{

					regAppInfo = iAppInfoArray[0];

					iAppInfoArray.Remove( 0 );							

					iLcRegAppOrder->RemoveArrayL( regAppInfo->Id() );

					delete regAppInfo;							

					}		

		    	}

			iAppInfoArray.ResetAndDestroy();

			FinalRegistrationUpdateL();	    	

			}		

		} 	

    }

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

// CLcServerShutDownTimer::RunError

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

//        

TInt CLcRegistry::RunError( TInt aError )

    {

    // Dont leave. Continue with the next operation

    return aError;

    }

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

// void CLcRegistry::FinalRegistrationUpdateL

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

//

void CLcRegistry::FinalRegistrationUpdateL()

    {

    // Resync all the existing applications. Their order could have been

    // changed because of the possible changes in the index ordering

    // Temporary array to assist copying of all content from one place

    // to another

    RPointerArray<CLcRegAppInfo> tempArray;

    while ( iAppInfoArray.Count())

        {

        CLcRegAppInfo* info = iAppInfoArray[0];

        iAppInfoArray.Remove( 0 );

        tempArray.Append( info );

        }

    // Insert back all temporary elements back into the Info Array

    TInt appcount = tempArray.Count();

	for( TInt i = 0; i < appcount; i++ )

		{

		User::LeaveIfError( iAppInfoArray.Append( tempArray[i] ));

		}

    // Now destroy all the elements back in the temporary array.

    tempArray.ResetAndDestroy();

    tempArray.Close();

	// Add all the appinfo to current list from new created list

	appcount = iAppInfoNewArray.Count();

	for( TInt i = 0; i < appcount; i++ )

		{

		User::LeaveIfError(iAppInfoArray.Append( iAppInfoNewArray[i] ));

		}

	iAppInfoNewArray.Reset();		

	DEBUG1("New List Count : %d", iAppInfoArray.Count())

	// Send a notification to registry engine that updation completed

	iRegistryObserver.RegistryUpdated();

    }  

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

// CLcRegistry::IsInMMc

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

//

	{

	TBool lResult = EFalse;

	TParse parse;

	parse.Set(aFileName,NULL,NULL);

	TPtrC lDrive = parse.Drive();

    TInt err,mmcDrive,fileDrive;

    err = RFs::CharToDrive( PathInfo::MemoryCardRootPath()[0], mmcDrive );    

    if (err == KErrNone)

        {