/*

* Copyright (c) 2002 - 2007 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:   ?Description

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include <hal.h>

#include "tsysinfoservicetests.h"

#include "tbatterystrengthasyn.h"

#include "tuseractivitynotifier.h"

#include "tautolocknotifier.h"

#include "sysinfoservice.h"

#include "entitykeys.h"

#include <coemain.h> 

using namespace SysInfo;

_LIT(KROMInstallDir,"\\system\\install\\");

_LIT(KS60ProductIdFile,"Series60v*.sis");

	const TPtrC KFeature[] = 

	{

	KCamera.operator()(),

	KMemoryCard.operator()(),

	KFMRadio.operator()(),

	KQwerty.operator()(),

	KWLan.operator()(),

	KUsb.operator()(),

	KPen.operator()(),

	KLED.operator()(),

	KCoverUI.operator()(),

	KSideVolumeKeys.operator()(),

	KVibra.operator()(),

	};

const TInt KSize = sizeof(KFeature)/sizeof(TPtrC);

// ============================ MEMBER FUNCTIONS ===============================

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

// Ctsysinfoservicetests::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void Ctsysinfoservicetests::Delete() 

    {

    }

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

// Ctsysinfoservicetests::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt Ctsysinfoservicetests::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

//Features

        ENTRY( "Features",			Ctsysinfoservicetests::FeaturesL),

//Battery

        ENTRY( "BatteryLevelSync",			Ctsysinfoservicetests::BatteryLevelAutoL),

        ENTRY( "BatteryStrengthASync",		Ctsysinfoservicetests::BatteryStrengthAsyncL),

        ENTRY( "BatteryChargeSync",			Ctsysinfoservicetests::BatteryChargingAutoL),

//Device

        ENTRY( "FirmwareVersion",		Ctsysinfoservicetests::FirmwareVersionL),

		ENTRY( "PlatformVersion",    	Ctsysinfoservicetests::PlatformVersionL),

		ENTRY( "SymbianOSversion",  	Ctsysinfoservicetests::SymbianOSVersionL),

		ENTRY( "MachineID",  			Ctsysinfoservicetests::MachineIDL),

		ENTRY( "ProductType",  			Ctsysinfoservicetests::ProductTypeL),

		ENTRY( "Manufacturer", 			Ctsysinfoservicetests::ManufacturerL),

		ENTRY( "PhoneModel", 			Ctsysinfoservicetests::PhoneModelL),

		ENTRY( "IMEINumber", 			Ctsysinfoservicetests::IMEINumberL),		

//General

        ENTRY( "ConnectedAcc",    Ctsysinfoservicetests::ConnectedAcc),

        ENTRY( "SetDisplayLang",    Ctsysinfoservicetests::SetDisplayLang),

        ENTRY( "GetDisplayLang",    Ctsysinfoservicetests::GetDisplayLang),

        ENTRY( "SetInputLang",    Ctsysinfoservicetests::SetInputLang),

        ENTRY( "SupportedLang",    Ctsysinfoservicetests::SupportedLang),

	    ENTRY( "InputLang",    Ctsysinfoservicetests::InputLang),

        ENTRY( "PredText",    Ctsysinfoservicetests::PredText),

        ENTRY( "VibraStatus",    Ctsysinfoservicetests::VibraStatus),

        ENTRY( "AvailableUSBModes",    Ctsysinfoservicetests::AvailableUSBModes),

        ENTRY( "ActiveUSBModes",    Ctsysinfoservicetests::ActiveUSBModes),

        ENTRY( "NotificationCancelVibra",    Ctsysinfoservicetests::NotificationCancelVibra),

        ENTRY( "CameraData",    Ctsysinfoservicetests::CameraData),

        ENTRY( "CameraDataWrongEntity", Ctsysinfoservicetests::CameraDataNegativeEntity),

        ENTRY( "CameraDataWrongKey",   Ctsysinfoservicetests::CameraDataNegativeKey),

//Connectivity

  		ENTRY( "ConnBluetooth",    Ctsysinfoservicetests::ConnBluetooth),

        ENTRY( "IRStatus",    Ctsysinfoservicetests::IRStatus),

        ENTRY( "GetActiveConnections",    Ctsysinfoservicetests::GetActiveConnections),

        ENTRY( "GetWlanMacAddress",    Ctsysinfoservicetests::GetWlanMacAddress),

        ENTRY( "GetActiveConnectionsCancel",    Ctsysinfoservicetests::GetActiveConnectionsCancel),

//Display

        ENTRY( "GetSetBrightness",		Ctsysinfoservicetests::GetSetBrightnessL),

		ENTRY( "GetSetScreensaverTimeOut",	Ctsysinfoservicetests::GetSetScreensaverTimeOutL),

		ENTRY( "UserInactivityNotifier",  Ctsysinfoservicetests::UserInactivityNotifierL),

		ENTRY( "SetGetAutoLockTime",  		Ctsysinfoservicetests::SetGetAutoLockTimeL),

		ENTRY( "AutoLockNotifier",  	Ctsysinfoservicetests::AutoLockNotifierL),

		ENTRY( "DisplayResolution",  	Ctsysinfoservicetests::DisplayResolutionL),

		ENTRY( "DisplayOrientation",  Ctsysinfoservicetests::DisplayOrientationL),

		ENTRY( "GetSetLightTimeOut",	Ctsysinfoservicetests::GetSetLightTimeOutL),		

		ENTRY( "GetSetWallPaper",		Ctsysinfoservicetests::GetSetWallPaperL),

		ENTRY( "GetSetKeyGaurdTime",	Ctsysinfoservicetests::GetSetKeyGaurdL),

//Memory

        ENTRY( "GetListofDrives",		Ctsysinfoservicetests::GetListofDrivesL),

		ENTRY( "GetDriveInfo",    		Ctsysinfoservicetests::GetDriveInfoL),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

TInt  Ctsysinfoservicetests::FeaturesL(CStifItemParser& )

	{	

    _LIT( KExample, "TestFeaturesL" );

    iLog->Log( KExample );

	TInt Err(PASS);

#if (!(defined(__WINS__) || defined(__WINSCW__)))

	TInt MachineId;

	HAL::Get(HALData::EMachineUid, MachineId);

	iLog->Log(_L("Device MachineID: %x"),MachineId );

	switch(MachineId)

	{

		case 0x20001857:	//E70

						Err |= TestE70();

						break;

		case 0x20000606:	//N6290

						Err |= TestN6290();

						break;

		case 0x101fb3e8:	

						Err |= TestDevlon();

						break;

		default:

						iLog->Log(_L("Unknown Device "));

						TestDevlon();

						Err |= PASS;

						break;

	}

#endif

	return Err;

	}

TInt  Ctsysinfoservicetests::FirmwareVersionL(CStifItemParser& /*aItem*/)

	{	

    _LIT( KExample, "FirmwareVersionL" );

    iLog->Log( KExample );

	TInt Err(PASS);

	__UHEAP_MARK;

	CSysInfoService *obj = CSysInfoService::NewL();

	CleanupStack::PushL(obj);

	CSysData* output=NULL;

	TRAPD(err,obj->GetInfoL(KDevice,KFirmwareVersion,output));

	if (!err)

		{

		if(!output)

			{

			Err |= FAIL;

			iLog->Log( _L("Output data Set to NULL") );

			}

		else

			{

			CleanupStack::PushL(output);

			if( CSysData::EStringData != output->DataType() )

				{

				iLog->Log( _L("Invalid output data") );

				Err |= FAIL;

				}

			else

				{

				TPtrC firmwareversion;

				((CStringData*)output)->StringData(firmwareversion);

				iLog->Log( _L("Firmware Version: %s"), firmwareversion.Ptr());

				if(!(firmwareversion.Length() > 0))

					{

					iLog->Log( _L("Null string returned..") );

					Err |= FAIL;

					}

				}

			CleanupStack::PopAndDestroy(output);

			}

		}

	else

		{

		Err |= err;

		iLog->Log( _L("GetInfo API returned error") );

		}

	CleanupStack::PopAndDestroy(obj);

	__UHEAP_MARKEND;

	return Err;

	}

TInt  Ctsysinfoservicetests::SymbianOSVersionL(CStifItemParser& /*aItem*/)

	{	

    _LIT( KExample, "SymbianOSVersionL" );

    iLog->Log( KExample );

	TInt Err(PASS);

	_LIT(KSymbianOsVersion,"OSVersion");

	__UHEAP_MARK;

	CSysInfoService *obj = CSysInfoService::NewL();

	CleanupStack::PushL(obj);

	CSysData* output;

	TRAPD(err,obj->GetInfoL(KDevice,KSymbianOsVersion,output));

	if (err == KErrNotFound)

		{

		iLog->Log( _L("SymbianOsVersion not supported") );

		}

	else

		{

		Err |= FAIL;

		iLog->Log( _L("GetInfo API should return KErrNotFound") );

		}

	CleanupStack::PopAndDestroy(obj);

	__UHEAP_MARKEND;

	return Err;

	}

TInt  Ctsysinfoservicetests::PlatformVersionL(CStifItemParser& /*aItem*/)

	{	

    _LIT( KExample, "PlatformVersionL" );

    iLog->Log( KExample );

	TInt Err(PASS);

	__UHEAP_MARK;

	CSysInfoService *obj = CSysInfoService::NewL();

	CleanupStack::PushL(obj);

	CSysData* output;

	TRAPD(err,obj->GetInfoL(KDevice,KPlatformVersion,output));

	if (!err)

		{

		if(!output)

			{

			Err |= FAIL;

			iLog->Log( _L("Output data Set to NULL") );

			}

		else

			{

			CleanupStack::PushL(output);

			//Check data type

			if( CSysData::EVersion != output->DataType() )

				{

				iLog->Log( _L("Invalid output data") );

				Err |= FAIL;

				}

			else

				{

				TInt Major,Minor;

				Major = ((CVersion*)output)->MajorVersion();

				Minor = ((CVersion*)output)->MinorVersion();

				iLog->Log( _L("Platform version: Major: %d, Minor: %d"), Major,Minor);

				TInt ExpectedMajor,ExpectedMinor;

				GetPlatformVersion(ExpectedMajor,ExpectedMinor);

				if(!(ExpectedMajor == Major && ExpectedMinor == Minor))

					{

					iLog->Log( _L("incorrect major minor versions returned..") );

					Err |= FAIL;

					}

				}

			CleanupStack::PopAndDestroy(output);

			}

		}

	else

		{

		Err |= err;

		iLog->Log( _L("GetInfo API returned error") );

		}

	CleanupStack::PopAndDestroy(obj);

	__UHEAP_MARKEND;

	return Err;

	}

TInt  Ctsysinfoservicetests::ProductTypeL(CStifItemParser& /*aItem*/)

	{	

    _LIT( KExample, "ProductTypeL" );

    iLog->Log( KExample );

	TInt Err(PASS);

	__UHEAP_MARK;

	CSysInfoService *obj = CSysInfoService::NewL();

	CleanupStack::PushL(obj);

	CSysData* output;

	TRAPD(err,obj->GetInfoL(KDevice,KProductType,output));

	if (!err)

		{

		if(!output)

			{

			Err |= FAIL;

			iLog->Log( _L("Output data Set to NULL") );

			}

		else

			{

			CleanupStack::PushL(output);

			//Check data type

			if( CSysData::EStringData != output->DataType() )

				{

				iLog->Log( _L("Invalid output data") );

				Err |= FAIL;

				}

			else

				{

#if ( !((defined(__WINS__) || defined(__WINSCW__))) )

				TPtrC ProductType;

				((CStringData*)output)->StringData(ProductType);

				iLog->Log( _L("Product Type: %s"), ProductType.Ptr());

#endif

				}

			CleanupStack::PopAndDestroy(output);

			}

		}

	else

		{

		Err |= err;

		iLog->Log( _L("GetInfo API returned error") );

		}

	CleanupStack::PopAndDestroy(obj);

	__UHEAP_MARKEND;

	return Err;

	}	

TInt  Ctsysinfoservicetests::MachineIDL(CStifItemParser& /*aItem*/)

	{	

    _LIT( KExample, "MachineIDL" );

    iLog->Log( KExample );

	TInt Err(PASS);

	__UHEAP_MARK;

	CSysInfoService *obj = CSysInfoService::NewL();

	CleanupStack::PushL(obj);

	CSysData* output;

	TRAPD(err,obj->GetInfoL(KDevice,KMachineID,output));

	if (!err)

		{

		if(!output)

			{

			Err |= FAIL;

			iLog->Log( _L("Output data Set to NULL") );

			}

		else

			{

			CleanupStack::PushL(output);

			//Check data type

			if( CSysData::EStatus != output->DataType() )

				{

				iLog->Log( _L("Invalid output data") );

				Err |= FAIL;

				}

			else

				{

				TInt MachineID;

				MachineID = ((CStatus*)output)->Status();

				iLog->Log( _L("Machine ID: %x"), MachineID);

				TInt ExpectedMachineId;

				HAL::Get(HALData::EMachineUid, ExpectedMachineId);

				if(!(ExpectedMachineId == MachineID))

					{

					iLog->Log( _L("Incorrect Machine ID") );

					Err |= FAIL;					

					}

				}

			CleanupStack::PopAndDestroy(output);

			}

		}

	else

		{

		Err |= err;

		iLog->Log( _L("GetInfo API returned error") );

		}

	CleanupStack::PopAndDestroy(obj);

	__UHEAP_MARKEND;

	return Err;

	}	

TInt  Ctsysinfoservicetests::ManufacturerL(CStifItemParser& /*aItem*/)

	{	

    _LIT( KExample, "ManufacturerL" );

    iLog->Log( KExample );

	TInt Err(PASS);

	__UHEAP_MARK;

	CSysInfoService *obj = CSysInfoService::NewL();

	CleanupStack::PushL(obj);

	CSysData* output;

	TRAPD(err,obj->GetInfoL(KDevice,KManufacturer,output));

	if (!err)

		{

		if(!output)

			{

			Err |= FAIL;

			iLog->Log( _L("Output Data Set to NULL") );

			}

		else

			{

			CleanupStack::PushL(output);

			//Check data type

			if( CSysData::EStringData != output->DataType() )

				{

				iLog->Log( _L("Invalid output data") );

				Err |= FAIL;

				}

			else

				{

				TPtrC Manufacturer;

				((CStringData*)output)->StringData(Manufacturer);

				iLog->Log( _L("PhoneModel: %s"), Manufacturer.Ptr());

				TBuf<100> manufacturer(Manufacturer);

				manufacturer.UpperCase();

				if( manufacturer.Compare(_L("NOKIA")) )

					{

					iLog->Log( _L("Incorrect Manufacturer Name") );

					Err |= FAIL;

					}

				CleanupStack::PopAndDestroy(output);

				}

			}

		}

	else

		{

		Err |= err;

		iLog->Log( _L("GetInfo API returned error") );

		}

	CleanupStack::PopAndDestroy(obj);

	__UHEAP_MARKEND;

	return Err;

	}	

TInt  Ctsysinfoservicetests::PhoneModelL(CStifItemParser& /*aItem*/)

	{	

    _LIT( KExample, "PhoneModelL" );

    iLog->Log( KExample );

	TInt Err(PASS);

	__UHEAP_MARK;

	CSysInfoService *obj = CSysInfoService::NewL();

	CleanupStack::PushL(obj);

	CSysData* output;

	TRAPD(err,obj->GetInfoL(KDevice,KPhoneModel,output));

	if (!err)

		{

		if(!output)

			{

			Err |= FAIL;

			iLog->Log( _L("Output data Set to NULL") );

			}

		else

			{

			CleanupStack::PushL(output);

			//Check data type

			if( CSysData::EStringData != output->DataType() )

				{

				iLog->Log( _L("Invalid output data") );

				Err |= FAIL;

				}

			else

				{

				TPtrC PhoneModel;

				((CStringData*)output)->StringData(PhoneModel);

				iLog->Log( _L("PhoneModel: %s"), PhoneModel.Ptr());

				if(!(PhoneModel.Length() > 2))

					{

					iLog->Log( _L("Invalid PhoneModel") );

					Err |= FAIL;

					}

				}

			CleanupStack::PopAndDestroy(output);

			}

		}