// Copyright (c) 2005-2009 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:

// apsserv.cpp

//

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#if !defined(__APA_INTERNAL_H__)

#include "apainternal.h"

#endif

#include "apaidpartner.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include <e32svr.h>

#include <u32hal.h>

#include "apsserv.h"

#include "APFREC.H"

#include "APSSES.H"

#include "APSSTD.H"

#include "../aplist/aplappregfinder.h"

#include "../aplist/aplapplistitem.h"

#include "APSSCAN.H"

#include "APSSTD.H"

#include "APASVST.H"

#include <datastor.h>

#include "APSRECCACHE.h"

#include "apsnnapps.h"

#include "../apfile/apinstallationmonitor.h"

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

#include "apgnotif.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 	

	};

//

// CApaAppArcServer

//

const TInt KAppListServerPriority=CActive::EPriorityStandard;

/**

NameApaServStartSemaphore

@internalTechnology

@released

*/

EXPORT_C TPtrC NameApaServStartSemaphore()

	{

	TPtrC nameApaServStartSemaphore(KAppArcServerSemaphore);

	return nameApaServStartSemaphore;

	}

/**

NameApaServServerThread

@internalTechnology

@released

*/

EXPORT_C TPtrC NameApaServServerThread()

	{

	TPtrC nameApaServServerThread(KAppArcServerThread);

	return nameApaServServerThread;

	}

EXPORT_C CApaAppArcServer* CApaAppArcServer::Self()

	{ // static

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

	}

EXPORT_C CApaAppArcServer* CApaAppArcServer::NewL()

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

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CApaAppArcServer::CApaAppArcServer(TInt aPriority)

	: CPolicyServer(aPriority,KApaServPolicy),

	iAppList(0),

	iTypeStoreModified(0),

	iLoadRecognizersOnDemand(KApaLoadDataRecognizersOnDemand),

	iLoadMbmIconsOnDemand(KApaLoadMbmIconsOnDemand),

	iForceRegistrationStatus(EForceRegistrationNone)

	{

#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

	}

void CApaAppArcServer::ConstructL()

	{

	StartL(KAppListServerName);

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

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

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

		}

	iAppList=CApaAppList::NewL(iFs, 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);

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

	ConstructPathsToMonitorL();	

	if ( iAppFsMonitor )

		{

		iAppFsMonitor->Start(ENotifyFile);

		iAppFsMonitor->SetBlocked(ETrue);			

		}

	TRAP_IGNORE(iAppList->InitListL(this));

	//

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

	iRecEcomMonitor->Start();

	// Create the EMIME type store manager (part of the app-framework_emime component)

	iMimeTypeToAppMappingsManager=CTypeStoreManager::NewL(iFs);

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

	if(!err)

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

	// Create the EMIME type store monitor

	iTypeStoreMonitor = CApaFsMonitor::NewL(iFs,iMimeTypeToAppMappingsManager->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);

	//

	iAppInstallationMonitor = CApaAppInstallationMonitor::NewL(this);

	iAppInstallationMonitor->Start();

	}

void CApaAppArcServer::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 CApaAppArcServer::~CApaAppArcServer()

	{

	if(iBaBackupSessionWrapper)

		iBaBackupSessionWrapper->DeRegisterBackupOperationObserver(*this);

	delete iAppInstallationMonitor;

	delete iAppList; // deletes scanners

	delete iMimeTypeRecognizer;

	delete iMimeTypeToAppMappingsManager;

	delete iAppFsMonitor;	

	delete iTypeStoreMonitor;

	delete iBaBackupSessionWrapper;

	delete iRecognitionCache;

	delete iRecEcomMonitor;

	iFs.Close();

	iWsSession.Close();	

	delete 	iRuleBasedPlugIns;

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

		delete iNonNativeApplicationTypeArray[i].iNativeExecutable;

	iNonNativeApplicationTypeArray.Close();

	delete iRecognizerUnloadTimer;

	iNonNativeApplicationTypeRegistry.Close();

	}

EXPORT_C void CApaAppArcServer::HandleInstallationStartEvent()

	{

	if ( iAppFsMonitor )

		{

		iAppFsMonitor->SetBlocked(ETrue);	

		}

	AppList().StopScan();

	}

EXPORT_C void CApaAppArcServer::HandleInstallationEndEventL()

	{

	if ( iAppFsMonitor )

		{

		iAppFsMonitor->SetBlocked(EFalse);	

		}

	AppList().RestartScanL();

	}

CSession2* CApaAppArcServer::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 CApaAppArcServSession::NewL(const_cast<CApaAppArcServer&>(*this), const_cast<RFs&>(iFs));

	}

//

// scanning code here

//

EXPORT_C TCallBack CApaAppArcServer::RescanCallBack()

	{

	return TCallBack(&AppFsNotifyWithForcedRegistrationsResetCallBack,this);

	}

TInt CApaAppArcServer::AppFsNotifyWithForcedRegistrationsResetCallBack(TAny* aPtr)

	{

	ASSERT(aPtr);

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

	return AppFsNotifyCallBack(aPtr);

	}

TInt CApaAppArcServer::AppFsNotifyCallBack(TAny* aObject)

	{

	ASSERT(aObject);

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

	return KErrNone;

	}

TInt CApaAppArcServer::PlugInNotifyCallBack(TAny* aObject)

	{

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

	ASSERT(aObject);

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

	return KErrNone;

	}

TInt CApaAppArcServer::TypeStoreNotifyCallback(TAny* aObject)

	{

	ASSERT(aObject);

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

	return KErrNone;

	}

void CApaAppArcServer::UpdateApps()

// update the list

	{

	// File system change, rescan

	TRAP_IGNORE(iAppList->StartIdleUpdateL (this));

	}

/*

Updates application list with force registered applications.

*/

void CApaAppArcServer::UpdateAppsByForceRegistration()

    {

    iForceRegistrationStatus|=EForceRegistrationRequested;

    UpdateApps();

    }

void CApaAppArcServer::NotifyUpdate(TInt aReason)

// tell all sessions to update their clients

	{

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

	TRAP_IGNORE(iAppList->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(iAppList->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=iMimeTypeToAppMappingsManager->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(iMimeTypeToAppMappingsManager->StoreL());

        }

	// iterate through sessions

	iSessionIter.SetToFirst();

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

	while (ses!=NULL)

		{

		if(iForceRegistrationStatus & EForceRegistrationRequested)

            {

             //Notify clients about completion of force registration. 

            ses->NotifyScanComplete();

            }

		else

            {

            ses->NotifyClients(aReason);

            }

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

		}

     if(iForceRegistrationStatus & EForceRegistrationRequested)

         {

         //If this function is called because of force registration, clear force registration request status and

        //set force registration applist change status

        iForceRegistrationStatus &= (~EForceRegistrationRequested);

         iForceRegistrationStatus |= EForceRegistrationAppListChanged;

         }

     else

         {

         //If this function is called not because of force registration, clear force registration applist change status. 

        iForceRegistrationStatus &= (~EForceRegistrationAppListChanged);        

         }

	}

void CApaAppArcServer::UpdatePlugIns()

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

	{

	//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(iMimeTypeRecognizer->LoadRecognizersL());

		}

	if (iRecognitionCache)

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

			// 1. New ECom Plugin is installed.