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

// Contains a number of utility classes that are of general use

// thoughout the TSY.

// 

//

/**

 @file

*/

#include "utils.h"

#include "CSimPhone.h"

RCall::THookStatus ConvertStateToHook(RMobileCall::TMobileCallStatus aStatus)

/**

	Convert a call state to a hook state.

*/

	{

	if(aStatus==RMobileCall::EStatusUnknown)

		return RCall::EHookStatusUnknown;

	if((aStatus==RMobileCall::EStatusIdle)||

	   (aStatus==RMobileCall::EStatusRinging))

	   return RCall::EHookStatusOn;

	return RCall::EHookStatusOff;

	}

RPhone::TMode ConvertStateToMode(RMobileCall::TMobileCallStatus aStatus)

/**

	Convert a call state to a RPhone::TMode state.

	Note that the mapping table is not entirely clear here.

	The following mappings have been used here:

		EStatusUnknown		=>	EModeUnknown

		EStatusIdle			=>	EModeIdle

		EStatusDialling		=>	EModeEstablishingLink

		EStatusRinging		=>	EModeEstablishingLink

		EStatusAnswering	=>	EModeEstablishingLink

		EStatusConnecting	=>	EModeEstablishingLink

		EStatusConnected	=>	EModeOnlineData

		EStatusHold			=>	EModeOnlineData

		EStatusHangingUp	=>	EModeOnlineData

  There is currently no mapping for EModeOnlineCommand, so this mode state will

  never be returned.

*/

	{

	if(aStatus==RMobileCall::EStatusUnknown)

		return RPhone::EModeUnknown;

	if(aStatus==RMobileCall::EStatusIdle)

		return RPhone::EModeIdle;

	if((aStatus==RMobileCall::EStatusDialling) ||

		(aStatus==RMobileCall::EStatusAnswering) ||

		(aStatus==RMobileCall::EStatusRinging) ||

		(aStatus==RMobileCall::EStatusConnecting))

		return RPhone::EModeEstablishingLink;

	if(aStatus==RMobileCall::EStatusConnected)

		return RPhone::EModeOnlineData;

	if(aStatus==RMobileCall::EStatusDisconnecting)

		return RPhone::EModeOnlineData;

	if(aStatus==RMobileCall::EStatusHold)

		return RPhone::EModeOnlineData;

	return RPhone::EModeUnknown;		// Dummy final return value.

	}

TBool IsStateActive(RMobileCall::TMobileCallStatus aStatus)

	{

	if((aStatus==RMobileCall::EStatusUnknown) ||

	   (aStatus==RMobileCall::EStatusIdle) ||

	   (aStatus==RMobileCall::EStatusRinging))

	   return EFalse;

	return ETrue;

	}

void ConvertAsciiSms(const TDesC8& aAsciiPdu, TDes8& aOctetPdu)

/**

 * Populate the SMS PDU from an ASCII representation, such as that stored in the configuration file.

 * This simply involves converting the ASCII representation in the configuration file

 * into a hex representation to complete the request.

 */

	{

	// Check that the ASCII PDU length is even

	__ASSERT_ALWAYS((aAsciiPdu.Length()&0x1)==0x0,SimPanic(EIllegalOddNumberOfCharactersInConfigFilePdu));

	TUint8 digit;

	TInt i;

	for(i=0;i<aAsciiPdu.Length();i+=2)

		{

		TLex8 lex(aAsciiPdu.Mid(i,2));

		TInt ret=lex.Val(digit,EHex);

		__ASSERT_ALWAYS(ret==KErrNone,SimPanic(EIllegalHexCharacterInConfigFilePdu));

		aOctetPdu.Append(&digit,1);

		}

	}

/**

Converts a buffer containing string of the hexadecimal characters,

representing the binary data, into this binary data!

@param aSrc The buffer containing text representation.

@param aDst Binary data will be written to this buffer.

*/

void ConvertTextToBinary(const TDesC& aSrc, TDes8& aDst)

	{

	// Check that the ASCII PDU length is even

	__ASSERT_ALWAYS((aSrc.Length()&0x1)==0x0, SimPanic(EInvalidParameterFormatInConfigFile));

	aDst.SetLength(aSrc.Length() / 2);

	for (TInt ii = 0; ii < aSrc.Length(); ii += 2)

		{

		TInt val = 0;

		if ((aSrc[ii] >= '0') && (aSrc[ii] <= '9'))

			{

			val = ((aSrc[ii] - '0') << 4);

			}

		else if ((aSrc[ii] >= 'A') && (aSrc[ii] <= 'F'))

			{

			val = ((aSrc[ii] - 'A' + 10) << 4);

			}

		if ((aSrc[ii+1] >= '0') && (aSrc[ii+1] <= '9'))

			{

			val += (aSrc[ii+1] - '0');

			}

		else if ((aSrc[ii+1] >= 'A') && (aSrc[ii+1] <= 'F'))

			{

			val += (aSrc[ii+1] - 'A' + 10);

			}

		aDst[ii/2] = (TUint8) val;

		}

	}

TInt AsciiToNum(const TPtrC8 aParam, TUint8& aVal)

/**

* Converts a hexadecimal or decimal value stored in a TPtrC to its TUint value

*

* @param aParam		TPtr pointing to the hexadecimal or decimal number to convert.

* @param aVal		TUint reference to the val converted.

* @return TInt		Standard error return.

*/

	{

	_LIT8(KHexPrefix,"0x");

	TInt ret=KErrNone;

	if(aParam.Left(2).Compare(KHexPrefix)==0)

		{

		TLex8 lex(aParam.Mid(2));

		ret=lex.Val(aVal,EHex);

		}

	else

		{

		TLex8 lex(aParam);

		ret=lex.Val(aVal,EDecimal);

		}

	return ret;

	}

TInt AsciiToNum(const TPtrC8 aParam, TUint16& aVal)

/**

* Converts a hexadecimal or decimal value stored in a TPtrC to its TUint value

*

* @param aParam		TPtr pointing to the hexadecimal or decimal number to convert.

* @param aVal		TUint reference to the val converted.

* @return TInt		Standard error return.

*/

	{

	_LIT8(KHexPrefix,"0x");

	TInt ret=KErrNone;

	if(aParam.Left(2).Compare(KHexPrefix)==0)

		{

		TLex8 lex(aParam.Mid(2));

		ret=lex.Val(aVal,EHex);

		}

	else

		{

		TLex8 lex(aParam);

		ret=lex.Val(aVal,EDecimal);

		}

	return ret;

	}

TInt AsciiToNum(const TPtrC8 aParam, TUint32& aVal)

/**

* Converts a hexadecimal or decimal value stored in a TPtrC to its TUint value

*

* @param aParam		TPtr pointing to the hexadecimal or decimal number to convert

* @param aVal		TUint reference to the val converted.

* @return TInt		Standard error return.

*/

	{

	_LIT8(KHexPrefix,"0x");

	TInt ret=KErrNone;

	if(aParam.Left(2).Compare(KHexPrefix)==0)

		{

		TLex8 lex(aParam.Mid(2));

		ret=lex.Val(aVal,EHex);

		}

	else

		{

		TLex8 lex(aParam);

		ret=lex.Val(aVal,EDecimal);

		}

	return ret;

	}

TInt AsciiToNum(const TPtrC8 aParam, TInt32& aVal)

/**

* Converts a hexadecimal or decimal value stored in a TPtrC to its TUint value

*

* @param aParam		TPtr pointing to the hexadecimal or decimal number to convert

* @param aVal		TUint reference to the val converted.

* @return TInt		Standard error return.

*/

	{

	_LIT8(KHexPrefix,"0x");

	TInt ret=KErrNone;

	if(aParam.Left(2).Compare(KHexPrefix)==0)

		{

		TLex8 lex(aParam.Mid(2));

		ret=lex.Val(aVal,EHex);

		}

	else

		{

		TLex8 lex(aParam);

		ret=lex.Val(aVal,EDecimal);

		}

	return ret;

	}

TInt ParseMixedBinaryAsciiDataL(TDes8& aTextToConvert)

/**

Parses aTextToConvert based on the following rules:

'\\' (double backslash) is used to denote a single '\'

(single backslash)

'\xnn' denote a byte of binary data where nn is in hex-decimal.

The '\xnn' in aTextToConvert is replaced by the binary byte

that it represents.

For example: If aTextToConvert contains "abc\\def\xFF",

after parsing, it will contain "abc\def?" where ? = 0xFF.

@param aTextToConvert Modifiable buffer which will be parsed. 

@return KErrNone if aTextToConvert is in valid

        EAdditionalParamDataFormatMixedBinaryAndAscii format.

        KErrArgument if aTextToConvert is in an incorrect format.

@panic KErrNoMemory if there is not enough memory to do the parsing.

*/

	{

	// Pointer to unparsed portion of additionalParamDataBuffer

	HBufC8* resultBuffer = HBufC8::NewLC(aTextToConvert.Length());

	__ASSERT_ALWAYS(resultBuffer, PanicClient(KErrNoMemory));

	TPtr8 result(resultBuffer->Des());

	// Position of backslash

	TInt pos = 0;

	while ((pos = aTextToConvert.Locate('\\')) != KErrNotFound)

		{

		// Check that the backslash is followed by at least one more character

		if ((pos+1) >= aTextToConvert.Length())

			{

			return KErrArgument;

			}

		TUint8 modifier = aTextToConvert[pos+1];

		// Parse depending on character after the backslash

		switch (modifier)

			{

		case '\\':

			// Next character after the '\' is another '\'.

			// Replace it with a single '\' and move

			// on.

			result.Append(aTextToConvert.Left(pos+1));

			aTextToConvert.Delete(0, pos+2);

			break;

		case 'x':

			// Next character is an 'x' so check that there are three 

			// characters after the backslash (one for the x and two

			// characters of HEX.

			if ((pos+3) >= aTextToConvert.Length()) 

				{

				return KErrArgument;

				}

			// Convert those to HEX and replace '\xNN' with this.

			result.Append(aTextToConvert.Left(pos));

			TUint8 hexAsInt;

			if (AsciiHexToNum(aTextToConvert.MidTPtr(pos+2,2), hexAsInt) != KErrNone)

				{

				return KErrArgument;

				}

			// Append the raw byte to the result

			result.SetLength(result.Length()+1);

			result[result.Length()-1] = hexAsInt;

			aTextToConvert.Delete(0, pos+4);

			break;		

			}

		} // End while

	aTextToConvert.Insert(0, result);

	CleanupStack::PopAndDestroy(resultBuffer);

	return KErrNone;

	}

/**

Returns the numerical value that corresponds to the numeric character

of its parameter (in base 17).

@param aDigit A char between '0' to '9' or between 'A' to 'G'

*/

TInt CharToSeptNumL(const TChar& aChar)

	{

	TInt ret = 0;

	if((aChar >= '0') && (aChar <= '9'))

		{

		ret = TUint(aChar) - '0';

		}

	else if((aChar >= 'A') && (aChar <= 'G'))

		{

		ret = TUint(aChar) - 'A' + 10;

		}

	else

		{

		User::Leave(KErrArgument);

		}

	return ret;

	}