// Copyright (c) 1999-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:
// smutsimparam.cpp
//
#include <smutsimparam.h>

#include <mmlist.h>

#include "SMCMMAIN.H"
#include <smscmds.h>
#include "SMUTSET.H"

/**
The UID for the stream into which the SIM parameters are stored.

@internalComponent
@deprecated
Should be moved to the cpp file for this class.
*/
const TUid KUidMsvSimSmsParams = {0x100081BC};

/**
Creates an operation that reads the SMS parameters from the SIM.

@param	aMtm
The UID for the SMS MTM.

@param	aService
The SMS Service settings Id.

@param	aMsvSession
A message server session.

@param	aObserverRequestStatus
The observer status to be completed.

@return
The operation encapsulating reading the SIM parameters. 

@post
The SMS parameters are stored in iSimParams.

@internalComponent
*/
CSmsSimParamOperation* CSmsSimParamOperation::ReadSimParamsL(TUid aMtm, TMsvId aService, CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)
	{
	CSmsSimParamOperation* self = new (ELeave) CSmsSimParamOperation(aMtm, aService, aMsvSession, aObserverRequestStatus);
	CleanupStack::PushL(self);
	
	self->iSimParams = CMobilePhoneSmspList::NewL();
	self->iState = EStateReadingSimParams;
	self->DoReadSimParamsL();
	
	CleanupStack::Pop(self);
	return self;
	}

/**
Creates an operation that writes the SMS parameters to the SIM.

@param	aList
The list of SIM parameters to be written.

@param	aMtm
The UID for the SMS MTM.

@param	aService
The SMS Service settings Id.

@param	aMsvSession
A message server session.

@param	aObserverRequestStatus
The observer status to be completed.

@return
The operation encapsulating writing the SIM parameters. 

@post
The SMS parameters are stored in the SIM.

@internalComponent
*/
CSmsSimParamOperation* CSmsSimParamOperation::WriteSimParamsL(const CMobilePhoneSmspList& aList, TUid aMtm, TMsvId aService, CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)
	{
	CSmsSimParamOperation* self = new (ELeave) CSmsSimParamOperation(aMtm, aService, aMsvSession, aObserverRequestStatus);
	CleanupStack::PushL(self);
	
	self->iSimParams = CMobilePhoneSmspList::NewL();
	self->iState = EStateWritingSimParams;
	self->DoWriteSimParamsL(aList);
	
	CleanupStack::Pop(self);
	return self;
	}

/** 
Gets the operation completion/error code for reading/writing the SMS parameters.

It returns a packaged TInt (TIntBuf) and not a packaged TSmsProgress.

The code can be intrepreted as follows:

KErrNone - the SMS parameters were successfully read/writte from/to the SIM

KErrNotSupported - the telephone handset and/or TSY module does not support 
reading/writing the SMS parameters.

KErrNotFound - no SMS parameters where found on the SIM.

Other system-wide error codes - may indicate a comms, telephony or memory error.

@return
A TIntBuf containing the operation completion/error code.
*/
EXPORT_C const TDesC8& CSmsSimParamOperation::ProgressL()
	{
	iProgressBuf = TIntBuf(iError);
	return iProgressBuf;
	}

/**
Constructor.
*/
CSmsSimParamOperation::CSmsSimParamOperation(TUid aMtm, TMsvId aService, CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)
:	CMsvOperation(aMsvSession, EPriorityStandard, aObserverRequestStatus),
	iError(KErrNone)
	{
	iService = aService;
	iMtm = aMtm;
	CActiveScheduler::Add(this);
	}

/**
Destructor.
*/
CSmsSimParamOperation::~CSmsSimParamOperation()
	{
	Cancel();
	delete iSimParams;
	delete iOperation;
	}

/**
Retrieves the read SIM parameters from the stream in the SMS Service entry.

The read SIM parameters are placed in the member data iSimParams.

@pre
The async read SIM parameters operation is complete.

@post
The parameters are retrived from the stream in the SMS Service entry and stored
in iSimParams.

@leave	KErrNotFound
There were no SIM parameters to read from the SIM.
*/
void CSmsSimParamOperation::DoRunReadSimParamsL()
	{
	CMsvEntry* entry = iMsvSession.GetEntryL(iService);
	CleanupStack::PushL(entry);
			
	CMsvStore* store = entry->ReadStoreL();
	CleanupStack::PushL(store);

	RestoreSimParamsL(*store, *iSimParams);

	const TInt count = iSimParams->Enumerate();

	if (!count)
		User::Leave(KErrNotFound);

	CleanupStack::PopAndDestroy(2, entry); //entry, store
	}

/**
Completes the observer with the value in iError.
*/
void CSmsSimParamOperation::Complete()
	{
	TRequestStatus* status = &iObserverRequestStatus;
	User::RequestComplete(status, iError);
	}

/**
Reads the SIM parameters from the SIM.

A read SIM parameters command is transferred to the SMS server MTM. It is this
operation that does the actual reading of SIM parameters.

@post
A ESmsMtmCommandReadSimParams comand operation is started.
*/
void CSmsSimParamOperation::DoReadSimParamsL()
	{
	TransferCommandL(ESmsMtmCommandReadSimParams);
	}

/**
Writes the SMS parameters to the SIM.

The new parameters to be stored are written to a stream in the SMS Service entry.
A write SIM parameters command is transferred to the SMS server MTM. It is this
operation that does the actual writing of SIM parameters.

@param	aList
A list wit the new SIM parameters.

@post
The new SIM parameters are stored in the message store and a ESmsMtmCommandWriteSimParams
comand operation is started.
*/
void CSmsSimParamOperation::DoWriteSimParamsL(const CMobilePhoneSmspList& aList)
	{
	CMsvEntry* entry = iMsvSession.GetEntryL(iService);
	CleanupStack::PushL(entry);
		
	CMsvStore* store = entry->EditStoreL();
	CleanupStack::PushL(store);

	StoreSimParamsL(*store, aList);

	CleanupStack::PopAndDestroy(2, entry); 

	TransferCommandL(ESmsMtmCommandWriteSimParams);
	}

/**
Requests the specified asynchronous command from the SMS server MTM.

The command Ids are defined by TSmsMtmCommand.

@param	aCommandId
The Id of the requested command.

@post
The requested command is started.

@see	TSmsMtmCommand
*/
void CSmsSimParamOperation::TransferCommandL(TInt aCommandId)
	{
	CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();
	CleanupStack::PushL(sel);
	sel->AppendL(iService);

	delete iOperation;
	iOperation = NULL;
	iOperation = iMsvSession.TransferCommandL(*sel, aCommandId, TPtrC8(), iStatus);

	CleanupStack::PopAndDestroy(sel);
	iObserverRequestStatus = KRequestPending;
	SetActive();
	}

/**
Gets a list of Service Centre addresses.

This function can only be used after a read/write SIM parameters operation has
completed. If the CSmsSimParamOperation::ProgressL API returns any an error
code other than KErrNone, or the SIM parameters contain no Service Centre 
addresses, then this function returns an empty list.

@return
The list of SMS parameters that only contain Service Centre addresses. A pointer
to the list object is left on the cleanup stack.
*/
EXPORT_C CMobilePhoneSmspList* CSmsSimParamOperation::ServiceCentersLC() const
	{
	TInt count = 0;
	count = iSimParams->Enumerate();

	CMobilePhoneSmspList* list = CMobilePhoneSmspList::NewL();
	CleanupStack::PushL(list);

	// Order important
	for (TInt i = 0; i < count; ++i)
		{
		const RMobileSmsMessaging::TMobileSmspEntryV1& smspEntry = iSimParams->GetEntryL(i);

		if (smspEntry.iValidParams & RMobileSmsMessaging::KSCAIncluded)
			{
			list->AddEntryL(smspEntry);
			}
		}
	return list;
	}

/**
Stores the contents of aList into the message store.

The supplied SIM parameters are stored in the KUidMsvSimSmsParams stream of the
message entry store specified. This should be the SMS Service entry. No checking
is performed to verify that the store is for the SMS service entry.

@param	aStore
The message entry store to write the parameters into.

@param	aList
The SMS parameters to be written.

@post
The contents of aList are stored in the message store. 

@internalTechnology
*/
EXPORT_C void CSmsSimParamOperation::StoreSimParamsL(CMsvStore& aStore, const CMobilePhoneSmspList& aList)
	{
	aStore.Remove(KUidMsvSimSmsParams);
	
	RMsvWriteStream writeStream;
	writeStream.AssignLC(aStore, KUidMsvSimSmsParams);

	writeStream << aList;
	writeStream.CommitL();
	aStore.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);
	}

/**
Restores the SIM parameters from message store.

The SIM parameters are restored from the KUidMsvSimSmsParams stream of the 
message entry store specified. This should be the SMS Service entry. No checking
is performed to verify that the store is for the SMS service entry.

@param	aStore
The message entry store to read the parameters from.

@param	aList
An output argument to conatin the restored SMS parameters.

@leave	KErrNotFound
The stream did not exist in the specified message entry store.

@post
The output argument aList contains the restored SIM parameters.

@internalTechnology
*/
EXPORT_C void CSmsSimParamOperation::RestoreSimParamsL(CMsvStore& aStore, CMobilePhoneSmspList& aList)
	{
	if (aStore.IsPresentL(KUidMsvSimSmsParams))
		{
		RMsvReadStream readStream;
		readStream.OpenLC(aStore, KUidMsvSimSmsParams);

		readStream >> aList;
		readStream.Close();

		CleanupStack::PopAndDestroy(&readStream); 
		}
	else
		{
		User::Leave(KErrNotFound);
		}
	}

/*
 *	Methods from CActive
 */

/**
Handles completed async operations.

If the async operation was to read the SIM parameters, then the SIM parameters 
are read from the appropriate stream in the SMS Service entry and placed in the
parameter member iSimParams.

If the async operation was to read the SIM parameters, then there is nothing 
more to do.

For both types of operation the observer for this operation is completed.

@pre
The async operation is complete

@post
The operation is complete

@leave	KErrNotFound
There were no SIM parameters to read from the SIM.

@panic	SMCM	3
There was an supported command.
*/
void CSmsSimParamOperation::RunL()
	{
	iError = iStatus.Int();

	if (iError == KErrNone)
		{
		TSmsProgressBuf progressBuf;
		progressBuf.Copy(iOperation->ProgressL());
		TSmsProgress progress = progressBuf();

		iError = progress.iError;

		if (iError == KErrNone)
			{
			switch (iState)
				{
				case EStateReadingSimParams:
					{
					DoRunReadSimParamsL();
					break;
					}
				case EStateWritingSimParams:
					{
					break;
					}
				default:
					{
					Panic(ESmscPanicUnexpectedCommand);
					}
				}
			}
		}
	
	Complete();
	}

/**
Cancels any pending async request.

The observer is completed with an value of KErrCancel.
*/
void CSmsSimParamOperation::DoCancel()
	{
	if (iOperation)
		{
		iOperation->Cancel();
		}

	iError = KErrCancel;
	Complete();
	}

/**
Handles leaves from RunL().

The observer is completed with the leave code aError.

@param	aError
The leave code from RunL().

@return
A value of KErrNone.
*/
TInt CSmsSimParamOperation::RunError(TInt aError)
	{
	iError = aError;
	Complete();
	return KErrNone;
	}