// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <e32svr.h>

#include <u32hal.h>

#include <bautils.h>

#include "APSSERV.H"

#include "APFREC.H"

#include "APSSES.H"

#include "APSSTD.H"

#include "../apfile/aprfndr.h"

#include "APGAPLST.H"

#include "APSSCAN.H"

#include "APSSTD.H"

#include "APASVST.H"

#include "datastor.h"

#include "APSRECCACHE.h"

#include "apsnnapps.h"

#include "../apfile/apuninstallmonitor.h"

#include "../apgrfx/apprivate.h"

#include "apsiconcaptionoverride.h"

_LIT(KAppArcServerSemaphore,"AppArcServerSemaphore");

_LIT(KAppArcServerThread,"AppArcServerThread");

_LIT(KAppRegistrationFileImportLocation, "?:\\private\\10003a3f\\import\\apps\\");

_LIT(KAppResourceAppsLocation, "?:\\resource\\apps\\");

_LIT(KNonNativeApplicationTypeRegistry, ":\\private\\10003a3f\\NonNativeTypes.dat");

/*

 * patchable const data values defined in ApsConstData.cpp

 */

IMPORT_C extern const TInt KApaLoadDataRecognizersOnDemand;

IMPORT_C extern const TInt KApaUnloadRecognizersTimeout;

IMPORT_C extern const TInt KApaDrivesToMonitor;

IMPORT_C extern const TInt KApaLoadMbmIconsOnDemand;

const TUint8 KPolicyElementWriteDeviceData = 0;

//To monitor all drives.

const TInt KApaMonitorAllDrives = 0x3FFFFFF;

const TUint KRangeCount = 3; 

const TInt KAppListServRanges[KRangeCount] = 

	{	

	EFirstUnrestrictedOpcodeInAppListServ,

	EFirstOpcodeNeedingWriteDeviceDataInAppListServ, 

	EAppListFirstUnusedOpcode,

	};

const TUint8 KElementsIndex[KRangeCount] =

	{

	CPolicyServer::EAlwaysPass,			//Always passing no capability required [0-99]

	KPolicyElementWriteDeviceData,		//Requires WriteDeviceData				 [100-(EAppListFirstUnusedOpcode-1)]

	CPolicyServer::ENotSupported, 		//Not Supported		[EAppListFirstUnusedOpcode-End]

	};

const CPolicyServer::TPolicyElement KPolicyElements[] = 

	{ 

	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteDeviceData), CPolicyServer::EFailClient} 

	};

const CPolicyServer::TPolicy KApaServPolicy =

	{

	CPolicyServer::EAlwaysPass, 

	KRangeCount,

	KAppListServRanges,

	KElementsIndex, 	

	KPolicyElements 	

	};

//////////////////////////////

// CApaAppListServer

//////////////////////////////

const TInt KAppListServerPriority=CActive::EPriorityStandard;

/**

NameApaServStartSemaphore

@internalTechnology

*/

EXPORT_C TPtrC NameApaServStartSemaphore()

	{

	TPtrC nameApaServStartSemaphore(KAppArcServerSemaphore);

	return nameApaServStartSemaphore;

	}

/**

NameApaServServerThread

@internalTechnology 

*/

EXPORT_C TPtrC NameApaServServerThread()

	{

	TPtrC nameApaServServerThread(KAppArcServerThread);

	return nameApaServServerThread;

	}

EXPORT_C CApaAppListServer* CApaAppListServer::Self()

	{ // static

	return static_cast<CApaAppListServer*>(Dll::Tls());

	}

EXPORT_C CApaAppListServer* CApaAppListServer::NewL(MApaAppStarter* aAppStarter)

// Create a new CApaAppListServer which owns it's own resources

	{

	CApaAppListServer* self=new(ELeave) CApaAppListServer(KAppListServerPriority);

	CleanupStack::PushL(self);

	self->ConstructL(aAppStarter);

	CleanupStack::Pop();

	return self;

	}

CApaAppListServer::CApaAppListServer(TInt aPriority)

	: CPolicyServer(aPriority,KApaServPolicy),

	iAppList(0),

	iTypeStoreModified(0),

	iLoadRecognizersOnDemand(KApaLoadDataRecognizersOnDemand),

	iLoadMbmIconsOnDemand(KApaLoadMbmIconsOnDemand)

	{

	#ifdef __WINS__

	// KApaLoadDataRecognizersOnDemand and KApaloadIconsOnDemand are Rom patchable constants,

	// so need an emulator equivalent

	// if WINS then read value from epoc.ini

	// requires licencees to set property in epoc.ini

	TInt halValue = 0;

	if (UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty, (TAny*)"patchdata_apserv_dll_KApaLoadDataRecognizersOnDemand", &halValue) == KErrNone)

		{

		iLoadRecognizersOnDemand = halValue;

		}

	if (UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty, (TAny*)"patchdata_apserv_dll_KApaLoadMbmIconsOnDemand", &halValue) == KErrNone)

		{

		iLoadMbmIconsOnDemand = halValue;

		}

	#endif

	__DECLARE_NAME(_S("CApaAppListServer"));

	}

void CApaAppListServer::ConstructL(MApaAppStarter* aAppStarter)

	{

	StartL(KAppListServerName);

	User::LeaveIfError(Dll::SetTls(this));

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

	iScanningFileRecognizer=CApaScanningFileRecognizer::NewL(iFs,aAppStarter);

	// Get the idle timeout delay from the commandline if specified. The default is 50000ms

	const TInt cmdLineLen = User::CommandLineLength();

	TInt idlePeriodicDelay=50000; //default value

	if(cmdLineLen)

		{

		_LIT(KIdleTimeout,"IDLE_TIMEOUT_PERIODIC_DELAY_");

		// Extract the command line into a buffer

		HBufC* cmdLine = HBufC::NewLC(cmdLineLen);

		TPtr cmdLinePtr = cmdLine->Des();

		User::CommandLine(cmdLinePtr);

		cmdLinePtr.UpperCase();

		// Check if there is an idle timeout value given

		TInt idleTimeOutArgPos = cmdLinePtr.Find(KIdleTimeout);

		if(KErrNotFound != idleTimeOutArgPos)

			{

			// Extract the value out of the command line argument

			const TInt idleTimeOutValuePos = idleTimeOutArgPos + KIdleTimeout().Length();

			TInt i = idleTimeOutValuePos;

			while (i < cmdLineLen)

				{

				TChar c(cmdLinePtr[i]);

				if (!c.IsDigit())

					{

					break;

					}

				i++;

				}

			TLex idleTimeOutParser(cmdLinePtr.Mid(idleTimeOutValuePos, (i-idleTimeOutValuePos)));

		  	User::LeaveIfError(idleTimeOutParser.Val(idlePeriodicDelay));	  					  	

			}

		// Check if the recognition cache should be used or not. By default the cache is used

		iRecognitionCache = 0;

		_LIT(KWithoutRecognitionCache,"WITHOUT_RECOGNITION_CACHE");

		if(KErrNotFound == cmdLinePtr.Find(KWithoutRecognitionCache))

			{

			iRecognitionCache = new (ELeave) CApsRecognitionCache(iFs);

			}

		_LIT(KTextShellMode,"TEXT_SHELL_MODE");

		if (KErrNotFound == cmdLinePtr.Find(KTextShellMode))

			{

			// We are NOT running in text shell mode so connect to wserv session

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

			iRuleBasedPlugIns = CApaScanningRuleBasedPlugIns::NewL();

			}

		CleanupStack::PopAndDestroy(cmdLine);		

		}

	else

		{

		// no arguments so cache is used

		iRecognitionCache = new (ELeave) CApsRecognitionCache(iFs);

		// and rule based plugins are enabled

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

		iRuleBasedPlugIns = CApaScanningRuleBasedPlugIns::NewL();

		}

	CApaAppRegFinder* appRegFinder=CApaAppRegFinder::NewL(iFs); //non-standard transfer of ownership, no need for CleanupStack

	iAppList=CApaAppList::NewL(iFs, appRegFinder, iLoadMbmIconsOnDemand, idlePeriodicDelay); // takes ownership of scanner

	// If the phone rebooted halfway through processing updates, there will be a log file left

	// look for one and recover if neccessary

	CApsNonNativeApplicationsManager::RecoverFromUpdateLogL(iFs);

	iDataRecognizer=CApaScanningDataRecognizer::NewL(iFs, !iLoadRecognizersOnDemand);

	ConstructPathsToMonitorL();	

	if ( iAppFsMonitor )

		{

		iAppFsMonitor->Start(ENotifyFile);

		iAppFsMonitor->SetBlocked(ETrue);			

		}

	TRAP_IGNORE(iAppList->InitListL(this));

#ifdef USING_ECOM_RECOGS

	iRecEcomMonitor=CApaEComMonitor::NewL(TCallBack(&PlugInNotifyCallBack,this));

	iRecEcomMonitor->Start();

#endif

	iTypeStoreManager=CTypeStoreManager::NewL(iFs);

	TRAPD(err,iTypeStoreManager->RestoreL());

	if(err==KErrNone)

		{

		User::LeaveIfError(iFs.Modified(iTypeStoreManager->IniFileName(),iTypeStoreModified));

		}

	iTypeStoreMonitor=CApaFsMonitor::NewL(iFs,iTypeStoreManager->IniFileName(),TCallBack(&TypeStoreNotifyCallback,this));

	iTypeStoreMonitor->Start(ENotifyWrite); // this presumably needs to be ENotifyWrite rather than ENotifyFile (the latter being used or the other CApaFsMonitor objects) because CTypeStoreManager internally uses CDictionaryFileStore::OpenL, which presumably itself uses RFile::Open, which isn't covered by ENotifyFile according to its documentation

	TypeStoreNotifyCallback(this);

	iBaBackupSessionWrapper=CBaBackupSessionWrapper::NewL();

	iBaBackupSessionWrapper->RegisterBackupOperationObserverL(*((MBackupOperationObserver*)this));

	TChar sysDrive = RFs::GetSystemDriveChar();

	TInt maxSizeofFileName = KNonNativeApplicationTypeRegistry().Length() + 1;

	iNonNativeApplicationTypeRegistry.CreateL(maxSizeofFileName);

	iNonNativeApplicationTypeRegistry.Append(sysDrive);

	iNonNativeApplicationTypeRegistry.Append(KNonNativeApplicationTypeRegistry());

	TRAP_IGNORE(InternalizeNonNativeApplicationTypeArrayL());	// We don't want a corrupt file to prevent from starting

	if(iLoadRecognizersOnDemand)

		{

		iRecognizerUnloadTimer=CPeriodic::NewL(EPriorityNormal);

		}

	iAppUnInstallMonitor = CApaAppUnInstallMonitor::NewL(this);

	iAppUnInstallMonitor->Start();

	iIconCaptionOverrides = new(ELeave) CApaIconCaptionOverrides();

	iIconCaptionObserver = CApaIconCaptionCenrepObserver::NewL(*iIconCaptionOverrides);

	iIconCaptionObserver->LoadOverridesL();

	}

void CApaAppListServer::ConstructPathsToMonitorL()

	{

	TInt drivesToMonitor = KApaDrivesToMonitor;

	#ifdef __WINS__

	// KApaDrivesToMonitor is a Rom patchable constant, so need an emulator equivalent

	// if WINS then read value from epoc.ini requires licencees to set property in epoc.ini

	// Usage: In epoc.ini patchdata_apserv_dll_KApaDrivesToMonitor 4

	TInt valueOfKApaDrivesToMonitor = 0;

	if (UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"patchdata_apserv_dll_KApaDrivesToMonitor",&valueOfKApaDrivesToMonitor) == KErrNone)

		{

		drivesToMonitor = valueOfKApaDrivesToMonitor;

		}

	#endif

	if ( drivesToMonitor != KApaMonitorAllDrives )

		{

		// 1. Create and add CApaFsNotifier for all locations belonging to a drive if the drive is set to monitor.

		// 2. Do this for all the drives which are required to monitor.

		TInt maskBit = 1;

		TChar driveLetter;

		//Only bits from 0(EDriveA)- 25(EDriveZ) are valid other bits are ignored from 32-bit KApaDrivesToMonitor.

		for ( TInt i = EDriveA; i <= EDriveZ; i++ )

			{

			if ( drivesToMonitor & maskBit )

				{

				RFs::DriveToChar(i,driveLetter);

				RBuf pathToBeMonitored;

				TBuf<1> drive;

				drive.Append(driveLetter);

				//Creating or Adding <driveLetter>:\private\10003a3f\import\apps\ path to monitor.

				pathToBeMonitored.CreateL(KAppRegistrationFileImportLocation());				

				CleanupClosePushL(pathToBeMonitored);

				pathToBeMonitored.Replace(0,1,drive);				

				if ( iAppFsMonitor == NULL )

					{

					iAppFsMonitor=CApaFsMonitor::NewL(iFs, pathToBeMonitored, TCallBack(&AppFsNotifyCallBack, this));

					}

				else

					{

					iAppFsMonitor->AddLocationL(pathToBeMonitored);		

					}

				CleanupStack::PopAndDestroy(&pathToBeMonitored);

				//Adding <driveLetter>:\resource\apps\ path to monitor.

				pathToBeMonitored.CreateL(KAppResourceAppsLocation());

				CleanupClosePushL(pathToBeMonitored);

				pathToBeMonitored.Replace(0,1,drive);			

				iAppFsMonitor->AddLocationL(pathToBeMonitored);

				CleanupStack::PopAndDestroy(&pathToBeMonitored);

				}

			maskBit = maskBit << 1;

			}	

		}

	else

		{

		iAppFsMonitor=CApaFsMonitor::NewL(iFs, KAppRegistrationFileImportLocation, TCallBack(&AppFsNotifyCallBack, this));

		iAppFsMonitor->AddLocationL(KAppResourceAppsLocation);

		}	

	}

EXPORT_C CApaAppListServer::~CApaAppListServer()

	{

	delete iIconCaptionObserver;

	delete iIconCaptionOverrides;

	if(iBaBackupSessionWrapper)

		iBaBackupSessionWrapper->DeRegisterBackupOperationObserver(*this);

	delete iAppUnInstallMonitor;

	delete iScanningFileRecognizer;

	delete iAppList; // deletes scanners

	delete iDataRecognizer;

	delete iTypeStoreManager;

	delete iAppFsMonitor;	

	delete iTypeStoreMonitor;

	delete iBaBackupSessionWrapper;

	delete iRecognitionCache;

#ifdef USING_ECOM_RECOGS

	delete iRecEcomMonitor;

#else

	iRecEcomMonitor = NULL;

#endif

	iFs.Close();

	iAppCmdLine=NULL;

	iWsSession.Close();	

	delete 	iRuleBasedPlugIns;

	for (TInt i=iNonNativeApplicationTypeArray.Count()-1; i>=0; --i)

		{

		delete iNonNativeApplicationTypeArray[i].iNativeExecutable;

		}

	iNonNativeApplicationTypeArray.Close();

	iCustomAppList.ResetAndDestroy();

	iCustomAppList.Close();

	delete iRecognizerUnloadTimer;

	iNonNativeApplicationTypeRegistry.Close();

	}

EXPORT_C void CApaAppListServer::HandleStartUninstallEvent()

	{

	if ( iAppFsMonitor )

		{

		iAppFsMonitor->SetBlocked(ETrue);	

		}

	AppList().StopScan();

	}

EXPORT_C void CApaAppListServer::HandleEndUninstallEventL()

	{

	if ( iAppFsMonitor )

		{

		iAppFsMonitor->SetBlocked(EFalse);	

		}

	AppList().RestartScanL();

	}

CSession2* CApaAppListServer::NewSessionL(const TVersion& aVersion,const RMessage2&/* aMessage*/) const

// Create a new server session.

	{

	// check we're the right version

	TVersion v(KAppListServMajorVersionNumber,KAppListServMinorVersionNumber,KAppListServBuildVersionNumber);

	if (!User::QueryVersionSupported(v,aVersion))

		User::Leave(KErrNotSupported);

	// make new session

	return CApaAppListServSession::NewL(const_cast<CApaAppListServer&>(*this), const_cast<RFs&>(iFs));

	}

//

// scanning code here

//

EXPORT_C TCallBack CApaAppListServer::RescanCallBack()

	{

	return TCallBack(&AppFsNotifyWithForcedRegistrationsResetCallBack,this);

	}

TInt CApaAppListServer::AppFsNotifyWithForcedRegistrationsResetCallBack(TAny* aPtr)

	{

	ASSERT(aPtr);

	reinterpret_cast<CApaAppListServer*>(aPtr)->AppList().ResetForcedRegistrations();

	return AppFsNotifyCallBack(aPtr);

	}

TInt CApaAppListServer::AppFsNotifyCallBack(TAny* aObject)

	{

	ASSERT(aObject);

	reinterpret_cast<CApaAppListServer*>(aObject)->UpdateApps();

	return KErrNone;

	}

TInt CApaAppListServer::PlugInNotifyCallBack(TAny* aObject)

	{

	//update the pre-Platform-security style  recognizers and rule-based plug-ins

	ASSERT(aObject);

	reinterpret_cast<CApaAppListServer*>(aObject)->UpdatePlugIns();

	return KErrNone;

	}

TInt CApaAppListServer::TypeStoreNotifyCallback(TAny* aObject)

	{

	ASSERT(aObject);

	reinterpret_cast<CApaAppListServer*>(aObject)->UpdateTypeStore();

	return KErrNone;

	}

void CApaAppListServer::UpdateApps()

// update the list

	{

	// File system change, rescan

	TRAP_IGNORE(iAppList->StartIdleUpdateL (this));

	}

void CApaAppListServer::NotifyUpdate(TInt aReason)

// tell all sessions to update their clients

	{

	// Updates the applist with the icon caption details from the Central Repository.

	TRAP_IGNORE(UpdateAppListByIconCaptionOverridesL());

	// The short caption value sets through the API has got the highest precedence over the

	// values found in either central repository or resource file.

	TRAP_IGNORE(UpdateAppListByShortCaptionL());

    //Delete any data mappings in service registry related to uninstalled applications.

    CArrayFixFlat<TUid>* uninstalledApps=iAppList->UninstalledAppArray();

    TBool modificationStatus=EFalse;

    TBool modified;

    if(uninstalledApps)

        {

        TInt count=uninstalledApps->Count();

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

            {

            modified=iTypeStoreManager->DeleteApplicationDataMappings((*uninstalledApps)[index]);

            //Set modificationStatus if any data mapping is removed from the service registry

            if(modified)

                modificationStatus=ETrue;

            }

        delete uninstalledApps;

        //If service registry is modified, store it to a file

        if(modificationStatus)

            TRAP_IGNORE(iTypeStoreManager->StoreL());

        }

	// iterate through sessions

	iSessionIter.SetToFirst();

	CApaAppListServSession* ses=static_cast<CApaAppListServSession*>(&(*iSessionIter++));

	while (ses!=NULL)

		{

		ses->NotifyClients(aReason);	

		ses=static_cast<CApaAppListServSession*>(&(*iSessionIter++));

		}

	}

void CApaAppListServer::UpdatePlugIns()

// update the pre-Platform-security style, ecom style recognizers and rule-based plug-ins

	{

	TRAP_IGNORE(iScanningFileRecognizer->ScanForRecognizersL());

	//we want the recognizers to be loaded either if:

	// 1) they are not loaded on demand

	// 2) they are loaded on demand and actively used

	// 3) they are loaded on demand but waiting for the timer to be unloaded

	if(!iLoadRecognizersOnDemand || iRecognizerUsageCount > 0 || (iRecognizerUnloadTimer && iRecognizerUnloadTimer->IsActive()))

		{

		TRAP_IGNORE(iDataRecognizer->LoadRecognizersL());

		}

	if (iRecognitionCache)

		{	// RecognitionCache is flushed if there are any changes in plugins, i.e.,if:

			// 1. New ECom Plugin is installed.

			// 2. Existing ECom Plugin is uninstalled.

		iRecognitionCache->Flush();

		}

	TRAP_IGNORE(iRuleBasedPlugIns->ScanForRuleBasedPlugInsL());

	}

void CApaAppListServer::UpdateTypeStore()

// Update the internal type store if things have changed

	{

	TRAP_IGNORE(DoUpdateTypeStoreL());

	}

void CApaAppListServer::DoUpdateTypeStoreL()

	{

	TTime modified;

	TInt err=iFs.Modified(iTypeStoreManager->IniFileName(),modified);

	// check the time stamp to see if we are interested in an update

	if (modified>iTypeStoreModified && err==KErrNone)

		{

		CTypeStoreManager* manager=CTypeStoreManager::NewL(iFs);