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

//

/**

 @file

*/

#include "Te_SimMisc.h"

#include "../../inc/simtsyglobalproperties.h"

const TInt KOneSecond=1000000;	// Used in a time out function, 1 second (in microSeconds)

//------------------------------------------------------------------

//			** TEST SimMisc STEPS ***

//------------------------------------------------------------------

CSignalAndBatteryStrengthTest::CSignalAndBatteryStrengthTest()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("SignalAndBatteryStrengthTest"));

	}

//------------------------------------------------------------------

TVerdict CSignalAndBatteryStrengthTest::doTestStepL( void )

/** 

 * This method retrieves a phone's Signal and Battery Strength Information.

 */

	{

    INFO_PRINTF1(_L("Get Signal Strength Information"));

	// Get Signal caps

	INFO_PRINTF1(_L("Calling RMobilePhone::GetSignalCaps()"));

	TUint32 capabilities;

	TInt ret = iPhone.GetSignalCaps(capabilities);

	if(ret) 

		{

		INFO_PRINTF2(_L("RMobilePhone::GetSignalCaps() returned %d"), ret);

		return EFail;

		}

	if(capabilities & RMobilePhone::KCapsGetSignalStrength)

		{

		INFO_PRINTF1(_L("Phone supports requests to get the current signal strength"));

		}

	if(capabilities & RMobilePhone::KCapsNotifySignalStrengthChange)

		{

		INFO_PRINTF1(_L("Phone supports requests for notification of change in signal strength"));

		}

	TInt32 signalStrength;

	TInt8 bars;

	RMobilePhone::TMobilePhoneBatteryInfoV1 battery;

	// Get Battery Caps

	INFO_PRINTF1(_L("Calling RMobilePhone::GetBatteryCaps()"));

	ret = iPhone.GetBatteryCaps(capabilities);

	if (ret)

		{

		INFO_PRINTF2(_L("RMobilePhone::GetBatteryCaps() returned: %d"), ret);

		return EFail;

		}

	if(capabilities & RMobilePhone::KCapsGetBatteryInfo)

		INFO_PRINTF1(_L("Phone supports requests to get the current battery info"));

	if(capabilities & RMobilePhone::KCapsNotifyBatteryInfoChange)

		INFO_PRINTF1(_L("Phone supports requests for notification of change in battery information."));

	INFO_PRINTF1(_L("Calling RMobilePhone::GetSignalStrength()"));

	iPhone.GetSignalStrength(iStatus, signalStrength, bars);

	User::WaitForRequest(iStatus);

	if (iStatus==KErrNone)

		{

		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Signal strength (in dBm) : %d")), signalStrength);

		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Signal strength (in display bars) : %d")), bars);

		}

	else{

		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Signal strength, Error %d returned.")), ret);

		return EFail;

		}

	INFO_PRINTF1(_L("Calling RMobilePhone::GetBatteryInfo()"));

	iPhone.GetBatteryInfo(iStatus, battery);

	User::WaitForRequest(iStatus);

	if (iStatus==KErrNone)

		{

		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Battery status : %d")), battery.iStatus);

		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Battery charge level : %d")), battery.iChargeLevel);

		}

	else{

		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Battery charge, Error %d returned.")), ret);

		return EFail;

	}

	// Cancel Requests

	INFO_PRINTF1(_L("Performing Cancel Requests for the above functions"));

	iPhone.GetSignalStrength(iStatus, signalStrength, bars);

	iPhone.CancelAsyncRequest(EMobilePhoneGetSignalStrength);

	User::WaitForRequest(iStatus);

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetSignalStrength Cancel status = %d")), iStatus.Int());

	return TestStepResult();

	}

//------------------------------------------------------------------

CSubscriberIdTest::CSubscriberIdTest()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("SubscriberIdTest"));

	}

//------------------------------------------------------------------

TVerdict CSubscriberIdTest::doTestStepL( void )

	{

    INFO_PRINTF1(_L("Get Subscriber ID"));

	RMobilePhone::TMobilePhoneSubscriberId subId;

	iPhone.GetSubscriberId(iStatus, subId);

	User::WaitForRequest(iStatus);

	if (iStatus==KErrNone)

		{

		INFO_PRINTF2(TRefByValue<const TDesC>(_L("SubscriberId: %S")), &subId);

		}

	else

		{

		INFO_PRINTF2(TRefByValue<const TDesC>(_L("GetSubscriberId status %d")), iStatus.Int());

		return EFail;

		}

	iPhone.GetSubscriberId(iStatus, subId);

	iPhone.CancelAsyncRequest(EMobilePhoneGetSubscriberId);

	User::WaitForRequest(iStatus);

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("RMobilePhone::GetSubscriberIdCancel status = %d")), iStatus.Int());

	return TestStepResult();

	}

//------------------------------------------------------------------

CPhoneStoreTest::CPhoneStoreTest()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("PhoneStoreTest"));

	}

//------------------------------------------------------------------

TVerdict CPhoneStoreTest::doTestStepL( void )

	{

	// Get phone store info for various phonebooks

	RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg infoPckg(info);

    INFO_PRINTF1(_L("Test the phone stores"));

	iPhone.GetPhoneStoreInfo(iStatus, infoPckg, KETelIccAdnPhoneBook);

	User::WaitForRequest(iStatus);

	if(iStatus.Int())

		{

		return EFail;

		}

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Store Name: %S")), &info.iName);

	TESTL(info.iType==RMobilePhoneStore::EPhoneBookStore);

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of used entries: %d")), info.iUsedEntries);

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of total entries: %d")), info.iTotalEntries);

	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phbkInfo;

	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg phbkInfoPckg(phbkInfo);

	iPhone.GetPhoneStoreInfo(iStatus, phbkInfoPckg, KETelIccAdnPhoneBook);

	User::WaitForRequest(iStatus);

	if(iStatus.Int())

		{

		return EFail;

		}

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Store Name: %S")), &phbkInfo.iName);

	TESTL(phbkInfo.iType==RMobilePhoneStore::EPhoneBookStore);

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of used entries: %d")), phbkInfo.iUsedEntries);

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Number of total entries: %d")), phbkInfo.iTotalEntries);

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Max text length: %d")), phbkInfo.iMaxTextLength);

	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Max number length: %d")), phbkInfo.iMaxNumLength);

	return TestStepResult();

	}

//------------------------------------------------------------------

CGetCaps::CGetCaps()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("GetCaps"));

	}

//------------------------------------------------------------------

TVerdict CGetCaps::doTestStepL( void )

	{

	RPhone::TCaps capabilities;

	RPhone::TStatus phoneStatus;

	RPhone::TPhoneInfo phoneInfo;

	TInt ret;

    INFO_PRINTF1(_L("Get Phone Capabilities"));

// Get Caps and print them

	INFO_PRINTF1(_L("Calling RMobilePhone::GetCaps()"));

	ret = iPhone.GetCaps(capabilities);

	if(ret) 

		{

		INFO_PRINTF2(_L("RMobilePhone::GetCaps() returned: %d"), ret);

		return EFail;

		}

	if(capabilities.iFlags & RPhone::KCapsUnknown)

		{

		INFO_PRINTF1(_L("The capabilities of the phone are not currently known"));

		}

	if(capabilities.iFlags & RPhone::KCapsData)

		{

		INFO_PRINTF1(_L("The phone supports data calls"));

		}

	if(capabilities.iFlags & RPhone::KCapsFaxClassOne)

		{

		INFO_PRINTF1(_L("The phone supports the fax class 1 interface"));

		}

	if(capabilities.iFlags &	RPhone::KCapsFaxClassOnePointZero)

		{

		INFO_PRINTF1(_L("The phone supports the fax class 1.0 interface"));

		}

	if(capabilities.iFlags & RPhone::KCapsFaxClassTwo)

		{

		INFO_PRINTF1(_L("The phone supports the fax class 2 interface"));

		}

	if(capabilities.iFlags & RPhone::KCapsFaxClassTwoPointZero)

		{

		INFO_PRINTF1(_L("The phone supports the fax class 2.0 interface"));

		}

	if(capabilities.iFlags & RPhone::KCapsFaxClassTwoPointOne)

		{

		INFO_PRINTF1(_L("The phone supports the fax class 2.1 interface"));

		}

	if(capabilities.iFlags & RPhone::KCapsVoice)

		{

		INFO_PRINTF1(_L("The phone supports voice calls"));

		}

	if(capabilities.iFlags & RPhone::KCapsEventModemDetection)

		{

		INFO_PRINTF1(_L("The phone supports modem detection events"));

		}

	if(capabilities.iFlags & RPhone::KCapsStealCommPort)

		{

		INFO_PRINTF1(_L("The phone supports the ability to take the comms port "));

		}

// Gets Status and prints info

	INFO_PRINTF1(_L("Calling RMobilePhone::GetStatus()"));	

	ret = iPhone.GetStatus(phoneStatus);

	if(ret) 

		{

		INFO_PRINTF2(_L("RMobilePhone::GetStatus() returned %d"), ret);

		return EFail;

		}

	switch(phoneStatus.iMode)

	{

	case RPhone::EModeUnknown:

		INFO_PRINTF1(_L("The phone is currently in an unknown state"));

		break;

	case RPhone::EModeIdle:

		INFO_PRINTF1(_L("The phone is currently idle"));

		break;

	case RPhone::EModeEstablishingLink:

		INFO_PRINTF1(_L("The phone is currently trying to establish a call"));

		break;

	case RPhone::EModeOnlineData:

		INFO_PRINTF1(_L("The phone is in the connected and \"on-line data\" state"));

		break;

	case RPhone::EModeOnlineCommand:

		INFO_PRINTF1(_L("The phone is in the connected and \"on-line command\" state"));

		break;

	}

	// Gives time to read the results

	INFO_PRINTF1(_L("Calling RMobilePhone::GetInfo()"));

	ret = iPhone.GetInfo(phoneInfo);

	if(ret) {

		INFO_PRINTF2(_L("RMobilePhone::GetInfo() returned %d"), ret);

		return EFail;

	}

	switch(phoneInfo.iDetection)

	{

		case RPhone::EDetectedPresent:

			INFO_PRINTF1(_L("The local modem is present"));

			break;

		case RPhone::EDetectedNotPresent:

			INFO_PRINTF1(_L("The local modem is not present"));

			break;

		case RPhone::EDetectedUnknown:

			INFO_PRINTF1(_L("Status of the local modem not detected"));

			break;

	}

	return TestStepResult();

	}

//------------------------------------------------------------------

CGetLinesStatus::CGetLinesStatus()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("GetLinesStatus"));

	}

//------------------------------------------------------------------

TVerdict CGetLinesStatus::doTestStepL( void )

	{

	TInt aCount;

	TInt i;					// Loop counter

	RPhone::TLineInfo	lineInfo;

    INFO_PRINTF1(_L("Testing the line(s) status"));

	TInt ret = iPhone.EnumerateLines(aCount);

	INFO_PRINTF2(_L("There are %d lines on this phone"), aCount);

	if(ret)

		{

		return EFail;

		}

	for(i=0;i<aCount;i++)

		{

		iPhone.GetLineInfo(i+1, lineInfo);

		switch(lineInfo.iStatus)

			{

			case RCall::EStatusUnknown:

				INFO_PRINTF3(_L("Line index %d: %S, Status: The call status is not currently known"), i+1, &lineInfo.iName);

				break;

			case RCall::EStatusIdle:

				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is idle"), i+1, &lineInfo.iName);

				break;

			case RCall::EStatusDialling:   

				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is dialling."), i+1, &lineInfo.iName);

				break;

			case RCall::EStatusRinging:

				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is ringing "), i+1, &lineInfo.iName);

				break;

			case RCall::EStatusAnswering:

				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is being answered"), i+1, &lineInfo.iName);

				break;

			case RCall::EStatusConnecting:

				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is connecting"), i+1, &lineInfo.iName);

				break;

			case RCall::EStatusConnected:

				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is connected and active"), i+1, &lineInfo.iName);

				break;

			case RCall::EStatusHangingUp:

				INFO_PRINTF3(_L("Line index %d: %S, Status: The call is being terminated"), i+1, &lineInfo.iName);

				break;

			}

		// Waits a bit

		User::After( 3 * KOneSecond);

		if(lineInfo.iLineCapsFlags & RLine::KCapsData)

			{

			INFO_PRINTF1(_L("The line supports data connections"));

			}

		if(lineInfo.iLineCapsFlags & RLine::KCapsFax)

			{

			INFO_PRINTF1(_L("The line supports fax connections"));

			}

		if(lineInfo.iLineCapsFlags & RLine::KCapsVoice)

			{

			INFO_PRINTF1(_L("The line supports voice connections"));

			}

		if(lineInfo.iLineCapsFlags & RLine::KCapsEventIncomingCall)

			{

			INFO_PRINTF1(_L("The line supports incoming call notification requests"));

			}

		}

	return TestStepResult();

	}

//------------------------------------------------------------------

CGetMultimodeCaps::CGetMultimodeCaps()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("GetMultimodeCaps"));

	}

//------------------------------------------------------------------

TVerdict CGetMultimodeCaps::doTestStepL( void )

{

	TUint32 capabilities;

    INFO_PRINTF1(_L("Testing the Multimode caps"));

	INFO_PRINTF1(_L("Calling RMobilePhone::GetMultimodeCaps()"));

	TInt ret = iPhone.GetMultimodeCaps(capabilities);

	if(ret) 

	{

		INFO_PRINTF2(_L("RMobilePhone::GetMultimodeCaps returned %d"), ret);

		return EFail;

	}

	if(capabilities & RMobilePhone::KCapsGsmSupported)	

		{

		INFO_PRINTF1(_L("Phone can operate in GSM 900/1800/1900 mode"));

		}

	if(capabilities & RMobilePhone::KCapsGprsSupported)

		{

		INFO_PRINTF1(_L("Phone can operate in GPRS mode"));

		}

	if(capabilities & RMobilePhone::KCapsAmpsSupported)

		{

		INFO_PRINTF1(_L("Phone can operate in AMPS 800 mode"));

		}

	if(capabilities & RMobilePhone::KCapsWcdmaSupported)

		{

		INFO_PRINTF1(_L("Phone can operate in W-CDMA mode"));

		}

	return TestStepResult();

	}

//------------------------------------------------------------------

CGetNetworkCaps::CGetNetworkCaps()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("GetNetworkCaps"));

	}

//------------------------------------------------------------------

TVerdict CGetNetworkCaps::doTestStepL( void )

{

	TUint32 aCaps;

    INFO_PRINTF1(_L("Getting the phone network caps"));

	INFO_PRINTF1(_L("Calling RMobilePhone::GetNetworkCaps()"));

	TInt ret = iPhone.GetNetworkCaps(aCaps);

	if(ret) 

	{

		INFO_PRINTF2(_L("RMobilePhone::GetNetworkCaps() returned %d"), ret);

		return EFail;

	}

	if(aCaps & RMobilePhone::KCapsGetRegistrationStatus)

		{

		INFO_PRINTF1(_L("The phone supports retrieval of current registration status"));

		}

	if(aCaps & RMobilePhone::KCapsNotifyRegistrationStatus)

		{

		INFO_PRINTF1(_L("The phone supports notifications of change in registration status"));

		}

	if(aCaps & RMobilePhone::KCapsGetCurrentMode)

		{

		INFO_PRINTF1(_L("The phone supports retrieval of current mode"));

		}

	if(aCaps & RMobilePhone::KCapsNotifyMode)

		{

		INFO_PRINTF1(_L("The phone supports notification of change in mode"));

		}

	if(aCaps & RMobilePhone::KCapsGetCurrentNetwork)

		{

		INFO_PRINTF1(_L("phone supports retrieval of current network information"));

		}

	if(aCaps & RMobilePhone::KCapsNotifyCurrentNetwork)

		{

		INFO_PRINTF1(_L("The phone supports notification of change of current network"));

		}

	if(aCaps & RMobilePhone::KCapsGetHomeNetwork)

		{

		INFO_PRINTF1(_L("The phone supports retrieval of home network information"));

		}