// Copyright (c) 2007-2010 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:
// Implementation of TStrtSimStatusMgr class.
//




/**
 @file
 @internalComponent
 @released
*/

#include "ssmuiproviderdll.h"
#include "swppolicy_simstatus.h"
#include "ssmdebug.h"

#include <ssm/ssmswppolicy.h>
#include <ssm/ssmstatemanager.h>
#include <ssm/ssmcommandlist.h>
#include <ssm/startupdomainpskeys.h>
#include <ssm/ssmcommandfactory.h>

EXPORT_C MSsmSwpPolicy* CSimStatuspolicy::NewL()
	{
	CSimStatuspolicy* self = new (ELeave) CSimStatuspolicy;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}
 
CSimStatuspolicy::CSimStatuspolicy()
	{
	}

CSimStatuspolicy::~CSimStatuspolicy()
	{
	delete iCommandList;
	iProperty.Close();
	}

void CSimStatuspolicy::ConstructL()
	{
	User::LeaveIfError(iProperty.Attach(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey()));
	}

void CSimStatuspolicy::Initialize(TRequestStatus& aStatus)
	{
	TRequestStatus* rs = &aStatus;
	User::RequestComplete(rs, KErrNone);
	}

void CSimStatuspolicy::InitializeCancel()
	{
	}

void CSimStatuspolicy::Release()
	{
	delete this;
	}

MSsmSwpPolicy::TResponse CSimStatuspolicy::TransitionAllowed(const TSsmSwp& aSwp, const RMessagePtr2& aMessage)
	{
	MSsmSwpPolicy::TResponse isTransitionAllowed = ENotAllowed;
	TBool hasCapability = aMessage.HasCapability(ECapabilityWriteDeviceData, __PLATSEC_DIAGNOSTIC_STRING( "Platsec violation for sim status transition" ));

	//Return as transition not allowed if it doesnt have sufficient capability
	if(!hasCapability)
		{
		return isTransitionAllowed;
		}

	switch (aSwp.Value())
		{
		case ESimNotSupported:
			isTransitionAllowed = IsSimNotSupportedTransitionAllowed();
			break;
		case ESimNotPresent:
			isTransitionAllowed = IsSimRemovedTransitionAllowed();
			break;
		case ESimReadable:
			isTransitionAllowed = IsSimReadableTransitionAllowed();
			break;
		case ESimUsable:
			isTransitionAllowed = IsSimUsableTransitionAllowed();
			break;
		case ESimNotReady:
			isTransitionAllowed = EAllowed;
			break;
		}

	return isTransitionAllowed;
	}

MSsmSwpPolicy::TResponse CSimStatuspolicy::IsSimReadableTransitionAllowed()
    {
    TInt simStatus;
    iProperty.Get(simStatus);

    if ((ESimStatusUninitialized == simStatus ||
    		ESimNotPresent == simStatus ||
    		ESimReadable == simStatus ||
    		(iSimHasBeenReadable && ESimUsable ==simStatus) ||
    		(iSimHasBeenReadable && ESimNotReady == simStatus) ) &&
    		CSsmUiSpecific::IsSimStateChangeAllowed())
    	{
    	iSimHasBeenReadable = ETrue;
    	return EAllowed;
    	}
    return ENotAllowed;
    }

MSsmSwpPolicy::TResponse CSimStatuspolicy::IsSimUsableTransitionAllowed()
	{
	TInt simStatus;
	iProperty.Get(simStatus);
	if ((ESimReadable == simStatus ||
			ESimNotPresent == simStatus ||
			ESimUsable == simStatus ||
			(iSimHasBeenUsable && ESimNotReady ==simStatus)) &&
			CSsmUiSpecific::IsSimStateChangeAllowed())
		{
		iSimHasBeenUsable = ETrue;
		return EAllowed;
		}
	return ENotAllowed;
	}

MSsmSwpPolicy::TResponse CSimStatuspolicy::IsSimNotSupportedTransitionAllowed()
	{
	TInt simStatus;
	iProperty.Get(simStatus);
	if (ESimStatusUninitialized == simStatus ||
			ESimNotSupported == simStatus)
		{
		return EAllowed;
		}
	return ENotAllowed;
	}

MSsmSwpPolicy::TResponse CSimStatuspolicy::IsSimRemovedTransitionAllowed()
	{
	TInt simStatus;
	iProperty.Get(simStatus);

	if ((ESimStatusUninitialized == simStatus ||
			ESimUsable == simStatus ||
			ESimReadable == simStatus ||
			ESimNotReady == simStatus ||
			ESimNotPresent == simStatus) &&
			CSsmUiSpecific::IsSimStateChangeAllowed())
		{
		return EAllowed;
		}
	return ENotAllowed;
	}

void CSimStatuspolicy::PrepareCommandList(const TSsmSwp& aSwp, TRequestStatus& aStatus)
	{
	TRAPD(err, DoPrepareCommandListL(aSwp));
	TRequestStatus* rs = &aStatus;
	User::RequestComplete(rs, err);
	}

void CSimStatuspolicy::DoPrepareCommandListL(const TSsmSwp& aSwp)
	{
	// Reset the command list
	delete iCommandList;
	iCommandList = NULL;
	iCommandList = CSsmCommandList::NewL();

  // Create a PS command to change the sim status PS for compatibility reasons
	MSsmCommand* cmdPS = SsmCommandFactory::ConstructSetPAndSKeyCommandLC(ECmdCriticalSeverity, CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), aSwp.Value());
	iCommandList->AppendL(cmdPS);
	CleanupStack::Pop(cmdPS);

	// Create a command to publish the SwP value
	MSsmCommand* cmdSwp = SsmCommandFactory::ConstructPublishSwpCommandLC(ECmdCriticalSeverity, ESsmWaitForSignal, aSwp);
	iCommandList->AppendL(cmdSwp);
	CleanupStack::Pop(cmdSwp);
	}

void CSimStatuspolicy::PrepareCommandListCancel()
	{
	delete iCommandList;
	iCommandList = NULL;
	}

CSsmCommandList* CSimStatuspolicy::CommandList()
	{
	CSsmCommandList* list = iCommandList;
	iCommandList = NULL;
	return list;
	}

void CSimStatuspolicy::HandleCleReturnValue(const TSsmSwp& aSwp, TInt aError, TInt aSeverity, TRequestStatus& aStatus)
	{
	(void)aSwp;
	(void)aSeverity;
	(void)aError;
	
	TRequestStatus* rs = &aStatus;
#if defined(_DEBUG)
	if(KErrNone != aError)
		{
		DEBUGPRINT3A("ERROR: Request SwP change for SIM status (SwP key %d) completed with error %d", aSwp.Key(), aError);
		}
	//Complete the status with the error which inturn panics SSM server	
	User::RequestComplete(rs, aError);
#else // _DEBUG
	//Completing the status with KErrNone to avoid panic in SSM server
	User::RequestComplete(rs, KErrNone);
#endif // _DEBUG
	}

void CSimStatuspolicy::HandleCleReturnValueCancel()
	{
	}