/*

* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Implements the SCR session class which is server-side session object.

*

*/

/**

 @file

 @internalComponent

 @released

*/

#include "scrserver.h"

#include "scrsubsession.h"

#include "scrrequestimpl.h"

#include "usiflog.h"

#include "usiferror.h"

using namespace Usif;

//

// CScrSession

//

CScrSession::CScrSession(CScrServer& aServer)

/**

	Intializes the SCR session object with the server handle.

 */

	:	CScsSession(aServer)

		{

		DEBUG_PRINTF(_L8("SCR session construction!"));

		}

CScrSession::~CScrSession()

/**

	Destructor for the SCR session object.

 */

	{

	DEBUG_PRINTF(_L8("SCR session destruction!"));

	CScrServer *server = static_cast<CScrServer*>(&iServer);

	// Take care to close all outstanding subsesions first, as we wouldn't be able to roll-back with open statements

	TRAP_IGNORE(CScsSession::CloseAllSubsessionsL());

	// Now roll-back transaction in case it wasn't committed or rolled back explicitly

	if(server->IsTransactionOwner(this))

		{

		TRAPD(err, server->RequestImpL()->RollbackTransactionL());

		if(KErrNone != err)

			{

			TRAP_IGNORE(server->ReconnectL());

			}

		server->SetTransactionOwner(NULL);

		}

	// Any error during writing log entries can be ignored as it is done in the destructor of SCR session

	// and error logs are already written inside the function.

	TRAP_IGNORE(server->RequestImpL()->FlushLogEntriesArrayL());

	}

CScrSession* CScrSession::NewL(CScrServer &aServer, const RMessage2& aMessage)

/**

	Factory function allocates new instance of CScrSession.

	@param aServer  SCR Server object.

	@param aMessage	Standard server-side handle to message. Not used.

	@return			Newly created instance of CScrSession which is owned by the caller.

 */

	{

	DEBUG_PRINTF2(_L("A new SCR session for the process(0x%x) is being created."), aMessage.SecureId().iId);

	(void)aMessage; // Happy the compiler in release mode

	CScrSession* self = new (ELeave) CScrSession(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CancelTransaction(TAny* aParam)

	{

	CScrServer *server = static_cast<CScrServer*>(aParam);

	TRAP_IGNORE(server->RequestImpL()->RollbackTransactionL());

	server->SetTransactionOwner(NULL);

	}

TBool CScrSession::DoServiceL(TInt aFunction, const RMessage2& aMessage)

/**

	Implement CScsSession by handling the supplied message.

	@param	aFunction		Function identifier without SCS code.

	@param	aMessage		Standard server-side handle to message.  Not used.

 */

	{

	TScrSessionFunction f = static_cast<TScrSessionFunction>(aFunction);

	CScrServer *server = static_cast<CScrServer*>(&iServer);

	TBool isImplicitTransaction = EFalse;	

	MutatingOperationsPreambleL(*server, f, isImplicitTransaction);

	if(isImplicitTransaction)

		{

		CleanupStack::PushL(TCleanupItem(CancelTransaction, server));

		}

	switch(f)

		{

		case ECreateTransaction:

			server->RequestImpL()->CreateTransactionL();

			server->SetTransactionOwner(this);

			break;

		case ERollbackTransaction:

			server->RequestImpL()->RollbackTransactionL();

			server->SetTransactionOwner(NULL);

			break;

		case ECommitTransaction:

			server->RequestImpL()->CommitTransactionL();

			server->SetTransactionOwner(NULL);

			break;

		case EAddComponent:

			server->RequestImpL()->AddComponentL(aMessage);

			break;

		case ESetComponentLocalizableProperty:

			server->RequestImpL()->SetComponentLocalizablePropertyL(aMessage);

			break;

		case ESetComponentNumericProperty:

			server->RequestImpL()->SetComponentIntPropertyL(aMessage);

			break;

		case ESetComponentBinaryProperty:

			server->RequestImpL()->SetComponentBinaryPropertyL(aMessage);

			break;			

		case ERegisterComponentFile:

			server->RequestImpL()->RegisterComponentFileL(aMessage);

			break;

		case ESetFileStringProperty:

			server->RequestImpL()->SetFileStrPropertyL(aMessage);

			break;

		case ESetFileNumericProperty:

			server->RequestImpL()->SetFileIntPropertyL(aMessage);

			break;

		case ESetComponentName:

			server->RequestImpL()->SetComponentNameL(aMessage);

			break;

		case ESetComponentVendor:

			server->RequestImpL()->SetVendorNameL(aMessage);

			break;

		case ESetComponentVersion:

			server->RequestImpL()->SetComponentVersionL(aMessage);

			break;

		case ESetIsComponentRemovable:

			server->RequestImpL()->SetIsComponentRemovableL(aMessage);

			break;

		case ESetIsComponentDrmProtected:

			server->RequestImpL()->SetIsComponentDrmProtectedL(aMessage);

			break;

		case ESetIsComponentHidden:

			server->RequestImpL()->SetIsComponentHiddenL(aMessage);

			break;

		case ESetIsComponentKnownRevoked:

			server->RequestImpL()->SetIsComponentKnownRevokedL(aMessage);

			break;

		case ESetIsComponentOriginVerified:

			server->RequestImpL()->SetIsComponentOriginVerifiedL(aMessage);

			break;

		case ESetComponentSize:

			server->RequestImpL()->SetComponentSizeL(aMessage);

			break;

		case EDeleteComponentProperty:

			server->RequestImpL()->DeleteComponentPropertyL(aMessage);

			break;

		case EDeleteFileProperty:

			server->RequestImpL()->DeleteFilePropertyL(aMessage);

			break;

		case EUnregisterComponentFile:

			server->RequestImpL()->UnregisterComponentFileL(aMessage);

			break;

		case EDeleteComponent:

			server->RequestImpL()->DeleteComponentL(aMessage);

			break;

		case EGetSingleComponentSize:

			server->RequestImpL()->GetComponentEntrySizeL(aMessage);

			break;

		case EGetSingleComponentData:

			server->RequestImpL()->GetComponentEntryDataL(aMessage);

			break;

		case EGetFilePropertiesSize:

			server->RequestImpL()->GetFilePropertiesSizeL(aMessage);

			break;

		case EGetFilePropertiesData:

			server->RequestImpL()->GetFilePropertiesDataL(aMessage);

			break;

		case EGetSingleFilePropertySize:

			server->RequestImpL()->GetSingleFilePropertySizeL(aMessage);

			break;

		case EGetSingleFilePropertyData:

			server->RequestImpL()->GetSingleFilePropertyDataL(aMessage);

			break;

		case EGetFileComponentsSize:

			server->RequestImpL()->GetFileComponentsSizeL(aMessage);

			break;

		case EGetFileComponentsData:

			server->RequestImpL()->GetFileComponentsDataL(aMessage);

			break;

		case EGetComponentPropertiesSize:

			server->RequestImpL()->GetComponentPropertiesSizeL(aMessage);

			break;

		case EGetComponentPropertiesData:

			server->RequestImpL()->GetComponentPropertiesDataL(aMessage);

			break;

		case EGetComponentSinglePropertySize:

			server->RequestImpL()->GetComponentSinglePropertySizeL(aMessage);

			break;

		case EGetComponentSinglePropertyData:

			server->RequestImpL()->GetComponentSinglePropertyDataL(aMessage);

			break;

		case EGetIsMediaPresent:

			server->RequestImpL()->GetIsMediaPresentL(aMessage);

			break;

		case ESetScomoState:

			server->RequestImpL()->SetScomoStateL(aMessage);

			break;

		case EGetPluginUidWithMimeType:

			server->RequestImpL()->GetPluginUidWithMimeTypeL(aMessage);

			break;

		case EGetPluginUidWithComponentId:

			server->RequestImpL()->GetPluginUidWithComponentIdL(aMessage);

			break;

		case EGetComponentIdListSize:

			server->RequestImpL()->GetComponentIdListSizeL(aMessage);

			break;

		case EGetComponentIdListData:

			server->RequestImpL()->GetComponentIdListDataL(aMessage);

			break;

		case EGetComponentFilesCount:

			server->RequestImpL()->GetComponentFilesCountL(aMessage);

			break;

		case EAddComponentDependency:

			server->RequestImpL()->AddComponentDependencyL(aMessage);

			break;

		case EDeleteComponentDependency:

			server->RequestImpL()->DeleteComponentDependencyL(aMessage);

			break;

		case EGetLocalComponentId:

			server->RequestImpL()->GetComponentIdL(aMessage);

			break;

		case EGetComponentWithGlobalIdSize:

			server->RequestImpL()->GetComponentWithGlobalIdSizeL(aMessage);

			break;

		case EGetComponentWithGlobalIdData:

			server->RequestImpL()->GetComponentWithGlobalIdDataL(aMessage);

			break;

		case EGetSupplierComponentsSize:

			server->RequestImpL()->GetSupplierComponentsSizeL(aMessage);

			break;

		case EGetSupplierComponentsData:

			server->RequestImpL()->GetSupplierComponentsDataL(aMessage);

			break;

		case EGetDependantComponentsSize:

			server->RequestImpL()->GetDependantComponentsSizeL(aMessage);

			break;

		case EGetDependantComponentsData:

			server->RequestImpL()->GetDependantComponentsDataL(aMessage);

			break;

		case EAddSoftwareType:

			server->RequestImpL()->AddSoftwareTypeL(aMessage);

			break;

		case EDeleteSoftwareType:

			server->RequestImpL()->DeleteSoftwareTypeL(aMessage);

			break;

		case EGetDeletedMimeTypes:

			server->RequestImpL()->GetDeletedMimeTypesL(aMessage);

			break;

		case EGetIsComponentOrphaned:

			server->RequestImpL()->GetIsComponentOrphanedL(aMessage);

			break;

		case EGetLogFileHandle:

			server->RequestImpL()->GetLogFileHandleL(aMessage);

			//RMessage2 object is closed by both TransferToClient() and SCS framework.

			//return EFalse to prevent SCS to close the message object.

			return EFalse;

		case EGetIsComponentOnReadOnlyDrive:

			server->RequestImpL()->GetIsComponentOnReadOnlyDriveL(aMessage);

			break;

		case EGetIsComponentPresent:

			server->RequestImpL()->GetIsComponentPresentL(aMessage);

			break;

		case ESetIsComponentPresent:

			server->RequestImpL()->SetIsComponentPresentL(aMessage);

			break;

		case EGetComponentSupportedLocalesListSize:

			server->RequestImpL()->GetComponentSupportedLocalesListSizeL(aMessage);

			break;

		case EGetComponentSupportedLocalesListData:

			server->RequestImpL()->GetComponentSupportedLocalesListDataL(aMessage);

			break;

		case EGetLocalizedComponentSize:

		    server->RequestImpL()->GetComponentLocalizedEntrySizeL(aMessage);

		    break;

		case EGetLocalizedComponentData:

		    server->RequestImpL()->GetComponentLocalizedEntryDataL(aMessage);

		    break;

		case EAddApplicationEntry:

		    server->RequestImpL()->AddApplicationEntryL(aMessage);

		    break;

		case EDeleteApplicationEntries:

		    server->RequestImpL()->DeleteAllAppsWithinPackageL(aMessage);

		    break;

		case EDeleteApplicationEntry:

		    server->RequestImpL()->DeleteApplicationEntryL(aMessage);

		    break;

        case EGetComponentIdForApp:

            server->RequestImpL()->GetComponentIdForAppL(aMessage);

            break;

        case EGetAppUidsForComponentSize:

            server->RequestImpL()->GetAppUidsForComponentSizeL(aMessage);

            break;

        case EGetAppUidsForComponentData:

            server->RequestImpL()->GetAppUidsForComponentDataL(aMessage);

            break;

        case EGenerateNonNativeAppUid:

            server->RequestImpL()->GenerateNonNativeAppUidL(aMessage);

            break;

        case EGetApplicationLaunchersSize:

            server->RequestImpL()->GetApplicationLaunchersSizeL(aMessage);

            break;

        case EGetApplicationLaunchersData:

            server->RequestImpL()->GetApplicationLaunchersDataL(aMessage);

            break;          

		default:

			User::Leave(KErrNotSupported);

			break;

		}//End of switch.

	if(isImplicitTransaction)

		{

		MutatingOperationsPostambleL(*server);

		CleanupStack::Pop(server);

		}

	return ETrue;

	}//End of function DoServiceL

void CScrSession::ApplySubsessionConstraintL(CScrServer& aServer)

	{// Check whether or not write operation is allowed. if a subsession is in progress

	 // a mutating operation is not allowed to make the subsession results consistent.

	if(aServer.SubsessionCount() > 0)

		{

		DEBUG_PRINTF(_L8("Subsession in progress. Database write access was rejected!"));

		User::Leave(KErrScrReadOperationInProgress);

		}

	}

void CScrSession::ApplyTransactionConstraintL(CScrServer& aServer, TBool& aCreateImplicitTransaction)

	{// Check whether a transaction is in progress and owned by this session.

	 // A mutating operation is not allowed if the transaction owned by another session.

	if(aServer.IsTransactionInProgress())

		{// A transaction is already in progress, check if it is owned by this session.

		if(!aServer.IsTransactionOwner(this))

			{

			DEBUG_PRINTF(_L8("Transaction in progress owned by another session. Database write access was rejected!"));

			User::Leave(KErrScrWriteOperationInProgress);

			}

		aCreateImplicitTransaction = EFalse;

		}

	else if(aCreateImplicitTransaction)

		{// No transaction is in progress. Start an implicit transaction to improve

		 // the performance of mutating APIs. The implicit transaction must be

		 // committed when the API request is completed successfully, or rolled back 

		 // if a failure occurs while performing the request.

		aServer.RequestImpL()->CreateTransactionL();

		aServer.SetTransactionOwner(this);

		}

	}

void CScrSession::MutatingOperationsPreambleL(CScrServer& aServer, TScrSessionFunction aFunction, TBool& aIsTransactionImplicit)

	{

	// In SCR server, there can be ONLY ONE active TRANSACTION. Concurrent and nested

	// transactions are not supported. A transaction can committed/cancelled only by 

	// its owning session. While a transaction in progress, other sessions can invoke

	// query APIs, but not mutating APIs. Only the owning session can invoke APIs altering

	// database data. Moreover, a reading session (subsession) cannot be created while a transaction

	// is in progress unless the transaction is owned by this session. A transaction cannot be created if a reading subsession exits.

	switch(aFunction)

		{

		case ECreateTransaction:

			{

			if(aServer.IsTransactionInProgress())

				{// A new transaction cannot be started if there is another in progress

				User::Leave(KErrScrWriteOperationInProgress);

				}			

			break;

			}

		case ERollbackTransaction:

		case ECommitTransaction:

			{

			if(!aServer.IsTransactionOwner(this))

				{

				DEBUG_PRINTF(_L8("There is no active transaction owned by this session!"));

				User::Leave(KErrScrNoActiveTransaction);

				}

			break;

			}

		case ESetComponentLocalizableProperty:

		case ESetComponentNumericProperty:

		case ESetComponentBinaryProperty:

		case ESetFileStringProperty:

		case ESetFileNumericProperty:

		case ESetComponentName:

		case ESetComponentVendor:

		case ESetComponentVersion:

		case ESetIsComponentRemovable:

		case ESetIsComponentDrmProtected:

		case ESetIsComponentHidden:

		case ESetIsComponentKnownRevoked:

		case ESetIsComponentOriginVerified:

		case ESetComponentSize:

		case EDeleteComponentProperty:

		case EDeleteFileProperty:

		case EAddComponentDependency:

		case EDeleteComponentDependency:

		case ESetIsComponentPresent:

			{ 			

			// These mutating operations consist of a single mutating database statement.

			// So, no need to create an implicit transaction

			TBool createImplicitTransaction = EFalse; 

			ApplyTransactionConstraintL(aServer,createImplicitTransaction);

			break;

			}

		case EAddComponent:

		case ERegisterComponentFile:

		case EUnregisterComponentFile:

		case EDeleteComponent:

		case EAddSoftwareType:

		case EDeleteSoftwareType:

		case EGetDeletedMimeTypes:

		case EAddApplicationEntry:

		case EDeleteApplicationEntries:

		case EDeleteApplicationEntry:

			{			

			// These mutating operations consist of two or more mutating database statements.

			// Therefore, an implicit transaction is begun if an explicit one doesn't exist.

			TBool createImplicitTransaction = ETrue; 

			ApplyTransactionConstraintL(aServer,createImplicitTransaction);

			aIsTransactionImplicit = createImplicitTransaction;

			break;

			}

		default:

			// Other operations do NOT require write permission. Do nothing.

			break;

		}

	}

void CScrSession::MutatingOperationsPostambleL(CScrServer& aServer)

	{

	// This function is called to commit the implicit transaction opened for a specific mutating request.

	aServer.RequestImpL()->CommitTransactionL();

	aServer.SetTransactionOwner(NULL);

	}

CScsSubsession* CScrSession::DoCreateSubsessionL(TInt aFunction, const RMessage2& /*aMessage*/)

/**

	Override CScsSession::DoCreateSubsessionL by allocating a new SCR subsession object.

	@param	aFunction		Function identifier without SCS code.

	@param	aMessage		Standard server-side handle to message.	

	@return					New, initialized instance of CScrSubsession, ownership is transferred.

 */

	{

	TScrSessionFunction f = static_cast<TScrSessionFunction>(aFunction);

    CScrServer *server = static_cast<CScrServer*>(&iServer);

	switch(f)

		{

	    // Allow read operation even if another transaction is in progress for these views.

		case ESubSessCreateComponentsView:

			return CComponentViewSubsession::NewL(*this);

        case ESubSessCreateAppRegistryView:

            return CAppRegistrySubsession::NewL(*this);

		}

	 // A read operation is disallowed for the following views incase a transaction from another session 

	 // is already in progress. 

    if(server->IsTransactionInProgress() && !server->IsTransactionOwner(this)) 

        {

        DEBUG_PRINTF(_L8("Transaction from another session is in progress. Subsession cannot be created!"));

        User::Leave(KErrScrWriteOperationInProgress);

        }   

	switch(f)

	    {  

		case ESubSessCreateFileList:

			return CFileListSubsession::NewL(*this);

		case ESubSessCreateAppInfoView:

		    return CAppInfoViewSubsession::NewL(*this);

		case ESubSessCreateAppRegInfo:

			return CApplicationRegInfoSubsession::NewL(*this);

		case ESubSessCreateRegInfoForApp:

		    return CRegInfoForApplicationSubsession::NewL(*this);

		default:

			User::Leave(KErrNotSupported);

			/*lint -unreachable */

			return 0;	// avoid compiler warning

		}

	}