--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/serviceproviders/sapi_sysinfo/tsrc/dev/servicetests/tsysinfoservicetests/src/tsysinfoservicetestsblocks.cpp Fri Jul 03 15:51:24 2009 +0100
@@ -0,0 +1,2696 @@
+/*
+* 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"
+
+using namespace SysInfo;
+_LIT(KROMInstallDir,"\\system\\install\\");
+_LIT(KS60ProductIdFile,"Series60v*.sis");
+_LIT(KDisplayLanguage,"DisplayLanguage");
+
+ 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),
+//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);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::IMEINumberL(CStifItemParser& /*aItem*/)
+ {
+ _LIT( KExample, "IMEINumberL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output;
+
+ TRAPD(err,obj->GetInfoL(KDevice,KIMEI,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 IMEINumber;
+ ((CStringData*)output)->StringData(IMEINumber);
+ iLog->Log( _L("IMEI: %s"), IMEINumber.Ptr());
+ if(!(IMEINumber.Length() >= 15))
+ {
+ iLog->Log( _L("Invalid producttype") );
+ Err |= FAIL;
+ }
+ }
+ CleanupStack::PopAndDestroy(output);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+TInt Ctsysinfoservicetests::GetListofDrivesL(CStifItemParser& /*aItem*/)
+ {
+ _LIT( KExample, "GetListofDrivesL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KMemory,KListDrives,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ //On Emulator this must give C:2,D:3,Z:25
+ if( CSysData::EDriveList != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ CDriveList* drivelist = (CDriveList*)output;
+ TInt count = drivelist->Count();
+ //atleast one drive.
+ if(count<=0)
+ {
+ iLog->Log( _L("Atlease One drive must be present") );
+ Err |= FAIL;
+ }
+ else
+ {
+ iLog->Log( _L("Available Drives: "));
+ for(TInt i=0;i<count;i++)
+ {
+ TInt driveno = (*drivelist)[i];
+ iLog->Log( _L("Drive (Number,Letter): (%d, %c)"),driveno,97+driveno );
+ if( driveno < 0 )
+ {
+ iLog->Log( _L("Invalid drive number found") );
+ Err |= FAIL;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy(output);
+ }
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::GetDriveInfoL(CStifItemParser& /*aItem*/)
+ {
+ _LIT( KExample, "GetDriveInfoL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KMemory,KListDrives,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ //On Emulator this must give C:2,D:3,Z:25
+ if( CSysData::EDriveList != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ CDriveList* drivelist = (CDriveList*)output;
+ TInt count = drivelist->Count();
+ //atleast one drive.
+ if(count<=0)
+ {
+ iLog->Log( _L("Atleast One drive must be present") );
+ Err |= FAIL;
+ }
+ else
+ {
+ for(TInt i=0;i<count;i++)
+ {
+ TInt driveno = (*drivelist)[i];
+ CSysData* input1 = CDriveInfo::NewL(driveno);
+ CleanupStack::PushL(input1);
+
+ CSysData* output1;
+
+ TRAPD(err,obj->GetInfoL(KMemory,KDriveInfo,output1,input1));
+ CleanupStack::PopAndDestroy(input1);
+ if(!err )
+ {
+ CleanupStack::PushL(output1);
+ User::LeaveIfError(DriveInfoL(output1));
+ CleanupStack::PopAndDestroy(output1);
+ }
+ else
+ {
+ if( err == KErrNotReady && driveno == 4)
+ {
+ iLog->Log( _L("Memory card not present"));
+ continue;
+ }
+ iLog->Log( _L("Error retriving drive information of %d drive, err: %d"),driveno,err);
+ Err |= FAIL;
+ }
+ }//for
+ }//count
+ }//datatype
+ CleanupStack::PopAndDestroy(output);
+ }//output
+ }//err
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ iLog->Log( _L("Test Completed err: %d"),Err);
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::DriveInfoL(CSysData* aOutput)
+{
+ TInt Err(PASS);
+ CDriveInfo* driveinfo = (CDriveInfo*)aOutput;
+
+ TInt drvno = driveinfo->DriveNumber();
+ iLog->Log( _L("Drive (Number,Letter): (%d, %c)"),drvno,97+drvno );
+ if( !(drvno >=0 && drvno <= EDriveZ ))
+ {
+ iLog->Log( _L("Incorrect drive number in output data") );
+ Err |= FAIL;
+ }
+
+ iLog->Log( _L("-------------------------------") );
+ TPtrC drvname;
+ driveinfo->DriveName(drvname);
+ iLog->Log( _L("Drive Name: %s"),drvname.Ptr() );
+
+ iLog->Log( _L("Total Space: %ld"),driveinfo->TotalSpace() );
+ if( driveinfo->TotalSpace() < 0)
+ {
+ iLog->Log( _L("Incorrect total space") );
+ Err |= FAIL;
+ }
+
+ iLog->Log( _L("Free Space: %ld"),driveinfo->FreeSpace() );
+ if( driveinfo->FreeSpace() < 0)
+ {
+ iLog->Log( _L("Incorrect free space") );
+ Err |= FAIL;
+ }
+
+ TInt CriticalLevel = driveinfo->CriticalSpace();
+ iLog->Log( _L("Critical Space: %d"),CriticalLevel );
+ if( CriticalLevel <= 0)
+ {
+ iLog->Log( _L("Incorrect Critical Sapce") );
+ Err |= FAIL;
+ }
+
+ iLog->Log( _L("Media Type: %d"),driveinfo->MediaType() );
+ if( !(driveinfo->MediaType() <= EMediaRotatingMedia) )
+ {
+ iLog->Log( _L("Incorrect media type") );
+ Err |= FAIL;
+ }
+
+ iLog->Log( _L("-------------------------------") );
+ return Err;
+ }
+
+
+TInt Ctsysinfoservicetests::BatteryLevelAutoL(CStifItemParser& )
+ {
+ _LIT( KExample, "BatteryLevelAutoL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+#if ( !(defined(__WINS__) || defined(__WINSCW__)) )
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+
+ _LIT(KBatteryLevel,"BatteryLevel");
+
+ TRAPD(err,obj->GetInfoL(KBattery,KBatteryLevel,output));
+ if ( err == KErrNotFound )
+ {
+ Err = PASS;
+ iLog->Log( _L("Battery Level Not supported "));
+ }
+ else
+ {
+ Err |= FAIL;
+ iLog->Log( _L("GetInfo API returned error: %d Expected Error: %d"), err,KErrNotFound);
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+ __UHEAP_MARKEND;
+
+#endif
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::BatteryChargingAutoL(CStifItemParser& )
+ {
+ _LIT( KExample, "BatteryChargingAutoL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+#if ( !(defined(__WINS__) || defined(__WINSCW__)) )
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+
+ TRAPD(err,obj->GetInfoL(KBattery,KChargingStatus,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 BatteryCharg;
+ BatteryCharg = ((CStatus*)output)->Status();
+
+ iLog->Log(_L("Battery Charger State: %d"),BatteryCharg);
+
+ if( !(BatteryCharg == 0 || BatteryCharg == 1) )
+ {
+ iLog->Log( _L("Invalid Battery Level : %d"),BatteryCharg);
+ Err |= FAIL;
+ }
+ }
+ CleanupStack::PopAndDestroy(output);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error: %d"), err);
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+ __UHEAP_MARKEND;
+
+#endif
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::BatteryStrengthAsyncL(CStifItemParser&)
+ {
+ _LIT( KExample, "BatteryStrengthAsyncL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+#if ( !(defined(__WINS__) || defined(__WINSCW__)) )
+ __UHEAP_MARK;
+ CBatteryStrengthAsync* test = CBatteryStrengthAsync::NewL(iLog);
+ test->Start();
+ Err = test->Result();
+ delete test;
+
+#endif
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::GetSetBrightnessL(CStifItemParser& /*aItem*/)
+ {
+ _LIT( KExample, "GetSetBrightnessL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KDisplay,KBrightness,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt OldBrightness;
+ CStatus* brightness = (CStatus*)output;
+ OldBrightness = brightness->Status();
+ iLog->Log( _L("System Brigthness Value: %d"),OldBrightness );
+ CleanupStack::PopAndDestroy(output);
+#ifdef _SET_BRIGHTNESS_SUPPORTED_
+ CStatus* set_bright_val = CStatus::NewL(80);
+ CleanupStack::PushL(set_bright_val);
+
+ TRAPD(err,obj->SetInfoL(KDisplay,KBrightness,set_bright_val));
+ if(!err)
+ {
+ iLog->Log( _L("Brigthness set to %d"),80 );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_bright_val);
+
+ iLog->Log( _L("Getting Brightness Value after setting to 80") );
+
+ CSysData* output1=NULL;
+ TRAP(err,obj->GetInfoL(KDisplay,KBrightness,output1));
+ if(!err)
+ {
+ if(!output1)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output1);
+ TInt cur_brightness = ((CStatus*)output1)->Status();
+ if (cur_brightness != 80)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Brightness value not set to 80, read val: %d"), cur_brightness);
+ }
+ else
+ {
+ iLog->Log( _L("Brightness value set to 80"));
+ }
+ CleanupStack::PopAndDestroy(output1);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfoL API returned error on secound attempt") );
+ }
+
+ iLog->Log( _L("Restoring Brightness Value to %d"), OldBrightness);
+ set_bright_val = CStatus::NewL(OldBrightness);
+ CleanupStack::PushL(set_bright_val);
+
+ TRAP(err,obj->SetInfoL(KDisplay,KBrightness,set_bright_val));
+ if(!err)
+ {
+ iLog->Log( _L("Brigthness Value restored to %d"),OldBrightness );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_bright_val);
+#endif
+ }
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::GetSetScreensaverTimeOutL(CStifItemParser& /*aItem*/)
+ {
+ _LIT( KExample, "GetSetScreensaverTimeOutL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KDisplay,KScreenSaverTimeOut,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt OldScrTimeOut;
+ CStatus* ScrTimeOut = (CStatus*)output;
+ OldScrTimeOut = ScrTimeOut->Status();
+
+ iLog->Log( _L("System Screen Saver Timeout Value: %d"),OldScrTimeOut );
+ CleanupStack::PopAndDestroy(output);
+#ifdef _SET_SCREESAVER_SUPPORTED_
+ CStatus* set_scrtimeout_val = CStatus::NewL(30);
+ CleanupStack::PushL(set_scrtimeout_val);
+
+ TRAPD(err,obj->SetInfoL(KDisplay,KScreenSaverTimeOut,set_scrtimeout_val));
+ if(!err)
+ {
+ iLog->Log( _L("Screen saver timeout set to %d"),30 );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_scrtimeout_val);
+
+ iLog->Log( _L("Getting Screen saver timeout Value after setting to 30") );
+
+ CSysData* output1=NULL;
+ TRAP(err,obj->GetInfoL(KDisplay,KScreenSaverTimeOut,output1));
+ if(!err)
+ {
+ if(!output1)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output1);
+ TInt cur_scrtimeout = ((CStatus*)output1)->Status();
+ if (cur_scrtimeout != 30)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Screen saver timeout value not set to 30, read val: %d"), cur_scrtimeout);
+ }
+ else
+ {
+ iLog->Log( _L("Brightness value set to 30"));
+ }
+ CleanupStack::PopAndDestroy(output1);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfoL API returned error on secound attempt") );
+ }
+
+ iLog->Log( _L("Restoring Screen saver timeout Value to %d"), OldScrTimeOut);
+ set_scrtimeout_val = CStatus::NewL(OldScrTimeOut);
+ CleanupStack::PushL(set_scrtimeout_val);
+
+ TRAP(err,obj->SetInfoL(KDisplay,KScreenSaverTimeOut,set_scrtimeout_val));
+ if(!err)
+ {
+ iLog->Log( _L("Screen saver value restored to %d"),OldScrTimeOut );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_scrtimeout_val);
+#endif
+ }
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::UserInactivityNotifierL(CStifItemParser& )
+ {
+ _LIT( KExample, "UserInactivityNotifierL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+
+ CTestUserActivity* test = CTestUserActivity::NewL(iLog,1,CTestUserActivity::ETESTINACTIVITY);
+ test->Start();
+ Err = test->Result();
+ delete test;
+
+ __UHEAP_MARKEND;
+
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::UserActivityNotifierL(CStifItemParser& )
+ {
+ _LIT( KExample, "UserInactivityNotifierL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+
+ CTestUserActivity* test = CTestUserActivity::NewL(iLog,1,CTestUserActivity::ETESTACTIVITY);
+ test->Start();
+ Err = test->Result();
+ delete test;
+
+ __UHEAP_MARKEND;
+
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::SetGetAutoLockTimeL(CStifItemParser& )
+ {
+ _LIT( KExample, "SetGetAutoLockTimeL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KDisplay,KAutoLockTime,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt OldAutolockTime;
+ CStatus* AutoLockTimeOut = (CStatus*)output;
+ OldAutolockTime = AutoLockTimeOut->Status();
+
+ iLog->Log( _L("System Auto Lock Time Value: %d"),OldAutolockTime );
+ CleanupStack::PopAndDestroy(output);
+#ifdef _SET_SCREESAVER_SUPPORTED_
+ CStatus* set_autolocktime_val = CStatus::NewL(1);
+ CleanupStack::PushL(set_autolocktime_val);
+
+ TRAPD(err,obj->SetInfoL(KDisplay,KAutoLockTime,set_autolocktime_val));
+ if(!err)
+ {
+ iLog->Log( _L("Auto Lock time set to %d"),1 );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_autolocktime_val);
+
+ iLog->Log( _L("Getting Auto Lock time Value after setting to 1") );
+
+ CSysData* output1=NULL;
+ TRAP(err,obj->GetInfoL(KDisplay,KAutoLockTime,output1));
+ if(!err)
+ {
+ if(!output1)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output1 data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output1);
+ TInt cur_autolocktime = ((CStatus*)output1)->Status();
+ if (cur_autolocktime != 1)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Auto lock time value not set to 1, read val: %d"), cur_autolocktime);
+ }
+ else
+ {
+ iLog->Log( _L("Auto lock value set to %d"),cur_autolocktime);
+ }
+ CleanupStack::PopAndDestroy(output1);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfoL API returned error on secound attempt") );
+ }
+
+ iLog->Log( _L("Restoring Auto lock time Value to %d"), OldAutolockTime);
+ set_autolocktime_val = CStatus::NewL(OldAutolockTime);
+ CleanupStack::PushL(set_autolocktime_val);
+
+ TRAP(err,obj->SetInfoL(KDisplay,KAutoLockTime,set_autolocktime_val));
+ if(!err)
+ {
+ iLog->Log( _L("Screen saver value restored to %d"),OldAutolockTime );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_autolocktime_val);
+#endif
+ }
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::AutoLockNotifierL(CStifItemParser& )
+ {
+ _LIT( KExample, "AutoLockNotifierL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+
+ CAutoLockNotifier* test = CAutoLockNotifier::NewL(iLog,1);
+ test->Start();
+ Err = test->Result();
+ delete test;
+
+ __UHEAP_MARKEND;
+
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::DisplayResolutionL(CStifItemParser& )
+ {
+ _LIT( KExample, "DisplayResolutionL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KDisplay,KDisplayResolution,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EResolution != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ CResolution* resolution = (CResolution*)output;
+ TInt xpix = resolution->XPixels();
+ TInt ypix = resolution->YPixels();
+ if( xpix <= 0 || ypix<= 0)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Incorrect Display Resolution.. "));
+ }
+
+ iLog->Log( _L("XPixels: %d"), xpix);
+ iLog->Log( _L("YPixels: %d"), ypix);
+ }
+ CleanupStack::PopAndDestroy(output);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::DisplayOrientationL(CStifItemParser& )
+ {
+ _LIT( KExample, "DisplayOrientationL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KDisplay,KDisplayOrientation,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ CStatus* orientation = (CStatus*)output;
+ TInt orient = orientation->Status();
+ iLog->Log( _L("Display Orientation: %d"), orient);
+ }
+ CleanupStack::PopAndDestroy(output);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+TInt Ctsysinfoservicetests::GetSetLightTimeOutL(CStifItemParser& )
+ {
+ _LIT( KExample, "GetSetLightTimeOutL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KDisplay,KLightTimeOut,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt OldLightTimeOut;
+ CStatus* LightTimeOut = (CStatus*)output;
+ OldLightTimeOut = LightTimeOut->Status();
+
+ iLog->Log( _L("System Light TimeOu Value: %d"),OldLightTimeOut );
+ CleanupStack::PopAndDestroy(output);
+#ifdef _SET_LIGHTSTIMEOUT_SUPPORTED_
+ CStatus* set_lighttimeout_val = CStatus::NewL(5);
+ CleanupStack::PushL(set_lighttimeout_val);
+
+ TRAPD(err,obj->SetInfoL(KDisplay,KLightTimeOut,set_lighttimeout_val));
+ if(!err)
+ {
+ iLog->Log( _L("Light timeout set to %d"),5 );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_lighttimeout_val);
+
+ iLog->Log( _L("Getting Light TimeOut Value after setting to 5") );
+
+ CSysData* output1=NULL;
+ TRAP(err,obj->GetInfoL(KDisplay,KLightTimeOut,output1));
+ if(!err)
+ {
+ if(!output1)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output1 data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output1);
+ TInt cur_lighttimeout = ((CStatus*)output1)->Status();
+ if (cur_lighttimeout != 5)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Light TimeOut value not set to 1, read val: %d"), cur_lighttimeout);
+ }
+ else
+ {
+ iLog->Log( _L("Light TimeOut value set to %d"),cur_lighttimeout);
+ }
+ CleanupStack::PopAndDestroy(output1);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfoL API returned error on secound attempt") );
+ }
+
+ iLog->Log( _L("Restoring Light Timeout Value to %d"), OldLightTimeOut);
+ set_lighttimeout_val = CStatus::NewL(OldLightTimeOut);
+ CleanupStack::PushL(set_lighttimeout_val);
+
+ TRAP(err,obj->SetInfoL(KDisplay,KLightTimeOut,set_lighttimeout_val));
+ if(!err)
+ {
+ iLog->Log( _L("Light TimeOut value restored to %d"),OldLightTimeOut );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+ CleanupStack::PopAndDestroy(set_lighttimeout_val);
+#endif
+ }
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::GetSetWallPaperL(CStifItemParser& )
+ {
+ _LIT( KExample, "GetSetWallPaperL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+/*
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KDisplay,KWallpaper,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt OldLightTimeOut;
+ CStatus* LightTimeOut = (CStatus*)output;
+ OldLightTimeOut = LightTimeOut->Status();
+
+ iLog->Log( _L("System Light TimeOu Value: %d"),OldLightTimeOut );
+ CleanupStack::PopAndDestroy(output);
+
+ CStatus* set_lighttimeout_val = CStatus::NewL(5);
+ CleanupStack::PushL(set_lighttimeout_val);
+
+ TRAPD(err,obj->SetInfoL(KDisplay,KLightTimeOut,set_lighttimeout_val));
+ if(!err)
+ {
+ iLog->Log( _L("Light timeout set to %d"),5 );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_lighttimeout_val);
+
+ iLog->Log( _L("Getting Light TimeOut Value after setting to 5") );
+
+ CSysData* output1=NULL;
+ TRAP(err,obj->GetInfoL(KDisplay,KLightTimeOut,output1));
+ if(!err)
+ {
+ if(!output1)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output1 data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output1);
+ TInt cur_lighttimeout = ((CStatus*)output1)->Status();
+ if (cur_lighttimeout != 5)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Light TimeOut value not set to 1, read val: %d"), cur_lighttimeout);
+ }
+ else
+ {
+ iLog->Log( _L("Light TimeOut value set to %d"),cur_lighttimeout);
+ }
+ CleanupStack::PopAndDestroy(output1);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfoL API returned error on secound attempt") );
+ }
+
+ iLog->Log( _L("Restoring Light Timeout Value to %d"), OldLightTimeOut);
+ set_lighttimeout_val = CStatus::NewL(OldLightTimeOut);
+ CleanupStack::PushL(set_lighttimeout_val);
+
+ TRAP(err,obj->SetInfoL(KDisplay,KLightTimeOut,set_lighttimeout_val));
+ if(!err)
+ {
+ iLog->Log( _L("Light TimeOut value restored to %d"),OldLightTimeOut );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+ CleanupStack::PopAndDestroy(set_lighttimeout_val);
+ }
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+*/
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::GetSetKeyGaurdL(CStifItemParser& /*aItem*/)
+ {
+ _LIT( KExample, "GetSetKeyGaurdL" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KDisplay,KKeyGaurdTime,output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data") );
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt OldKeyGaurdTime;
+ CStatus* keygaurdtime = (CStatus*)output;
+ OldKeyGaurdTime = keygaurdtime->Status();
+ iLog->Log( _L("System keygaurdtime Value: %d"),OldKeyGaurdTime );
+ CleanupStack::PopAndDestroy(output);
+#ifdef _SET_KEYGAURD_SUPPORTED_
+ CStatus* set_keygaurdtime_val = CStatus::NewL(5);
+ CleanupStack::PushL(set_keygaurdtime_val);
+
+ TRAPD(err,obj->SetInfoL(KDisplay,KKeyGaurdTime,set_keygaurdtime_val));
+ if(!err)
+ {
+ iLog->Log( _L("KeyGaurd Time set to %d"),5 );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_keygaurdtime_val);
+
+ iLog->Log( _L("Getting KeyGaurd Time Value after setting to 5") );
+
+ CSysData* output1=NULL;
+ TRAP(err,obj->GetInfoL(KDisplay,KKeyGaurdTime,output1));
+ if(!err)
+ {
+ if(!output1)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL") );
+ }
+ else
+ {
+ CleanupStack::PushL(output1);
+ TInt cur_keygaurdval = ((CStatus*)output1)->Status();
+ if (cur_keygaurdval != 5)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("KeyGaurd Time value not set to 5, read val: %d"), cur_keygaurdval);
+ }
+ else
+ {
+ iLog->Log( _L("KeyGaurd Time value set to 5"));
+ }
+ CleanupStack::PopAndDestroy(output1);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfoL API returned error on secound attempt") );
+ }
+
+ iLog->Log( _L("Restoring KeyGaurd Time Value to %d"), OldKeyGaurdTime);
+ set_keygaurdtime_val = CStatus::NewL(OldKeyGaurdTime);
+ CleanupStack::PushL(set_keygaurdtime_val);
+
+ TRAP(err,obj->SetInfoL(KDisplay,KKeyGaurdTime,set_keygaurdtime_val));
+ if(!err)
+ {
+ iLog->Log( _L("KeyGaurd Time Value restored to %d"),OldKeyGaurdTime );
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("SetInfoL API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(set_keygaurdtime_val);
+#endif
+ }
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+
+ CleanupStack::PopAndDestroy(obj);
+
+ __UHEAP_MARKEND;
+ return Err;
+ }
+
+
+
+
+//returns OS VERSION
+void Ctsysinfoservicetests::GetOSVersion(TInt& aMajor,TInt& aMinor)
+{
+ TInt MachineId;
+ HAL::Get(HALData::EMachineUid, MachineId);
+ switch(MachineId)
+ {
+ case 0x101F466A :
+ case 0x101F8C19 :
+ case 0x101FB2B1 :
+ case 0x10005E33 :
+ case 0X101FA031 :
+ case 0x101F9071 :
+ aMajor = 6;
+ aMinor = 1;
+ break;
+ case 0x101F408B :
+ case 0x101FB2AE :
+ case 0x10200AC6 :
+ case 0x101F6B26 :
+ aMajor = 7;
+ aMinor = 0;
+ break;
+ case 0x10200F97 :
+ case 0x101FB3DD :
+ case 0x101FB3F4 :
+ case 0x101FB3F3 :
+ case 0x101F3EE3 :
+ case 0x101FBE09 :
+ case 0x101F8ED1 :
+ case 0x1020E048 :
+ case 0x101FF525 : //iversion = 7.0s;
+ aMajor = 7;
+ aMinor = 0;
+ break;
+
+ case 0x101FBB55 :
+ case 0x10200f99 :
+ case 0x10200F9C :
+ case 0x10200F9B :
+ // iversion 8.0a;
+ aMajor = 8;
+ aMinor = 0;
+ break;
+ case 0x10200F9A :
+ case 0x10200F98 :
+ //iversion 8.1a;
+ aMajor = 8;
+ aMinor = 1;
+ break;
+ case 0x1020E285 :
+ case 0x10274BFA :
+ case 0x10274BF9 :
+ case 0x200005F8 :
+ case 0x20000602 :
+ case 0x200005FF :
+ case 0x200005FB :
+ case 0x200005FE :
+ case 0x20000601 :
+ case 0x200005F9 :
+ case 0x200005FC :
+ case 0x200005FA :
+ case 0x20000600 :
+ case 0x20000605 :
+ case 0x20002495 :
+ case 0x20001856 :
+ case 0x20001858 :
+ case 0x20002D7F :
+ case 0x20001859 :
+ case 0x20000604 :
+ case 0x20001857 :
+ aMajor = 9;
+ aMinor = 1;
+ break;
+ case 0x20002D7C :
+ case 0x20002D7B :
+ case 0x20002D7E :
+ case 0x20000606 :
+ case 0x2000060A :
+ case 0x2000060B :
+ case 0x20002496 :
+ aMajor = 9;
+ aMinor = 2;
+ break;
+ case 0x101fb3e8 :
+ case 0x2000da56 :
+ aMajor = 9;
+ aMinor = 3;
+ break;
+ }
+}
+
+void Ctsysinfoservicetests::GetPlatformVersion(TInt& aMajor, TInt& aMinor)
+{
+ //get platform version
+ RFs fs;
+ CDir* result;
+
+
+ CleanupClosePushL(fs);
+ User::LeaveIfError(fs.Connect());
+
+ TFindFile ff(fs);
+ TInt err(KErrNone);
+ err = ff.FindWildByDir(KS60ProductIdFile,KROMInstallDir,result);
+ if(!err)
+ {
+ CleanupStack::PushL(result);
+ User::LeaveIfError(result->Sort(ESortByName|EDescending));
+
+ if(result->Count() >= 0)
+ {
+ TPtrC filename = (*result)[0].iName;
+ TLex parser((filename));
+ parser.Inc(9);
+
+ // Get major version value
+ err = parser.Val(aMajor);
+
+ if( parser.Get() != '.' || err )
+ {
+ aMajor = 0;
+ }
+ else
+ {
+ // Get minor version value
+ err = parser.Val(aMinor);
+ if( err )
+ {
+ aMajor = 0;
+ aMinor = 0;
+ }
+ }
+ }
+ // clean up result
+ CleanupStack::PopAndDestroy(result);
+ }
+ // clean up file session fs.
+ CleanupStack::PopAndDestroy(&fs);
+}
+
+TInt Ctsysinfoservicetests::TestE70()
+ {
+ _LIT( KExample, "TestE70L" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ TInt ExpectedValue[KSize]=
+ {
+ ETrue, //KCamera
+ ETrue, //KMemoryCard
+ EFalse, //KFMRadio
+ ETrue, //KQwerty
+ ETrue, //KWLan
+ ETrue, //KUsb
+ EFalse, //KPen
+ EFalse, //KLED
+ EFalse, //KCoverUI
+ EFalse, //KSideVolumeKeys
+ ETrue, //KVibra
+ };
+
+ for(TInt i=0;i<KSize;i++)
+ {
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KFeatures,KFeature[i],output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL feature: %s"),KFeature[i].Ptr() );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data: %s"), KFeature[i].Ptr());
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt IsSupported = ((CStatus*)output)->Status();
+
+ if(IsSupported)
+ {
+ iLog->Log( _L("Feature %s: Supported"), KFeature[i].Ptr());
+ }
+ else
+ {
+ iLog->Log( _L("Feature %s: Not Supported"), KFeature[i].Ptr());
+ }
+
+ if(ExpectedValue[i] != IsSupported)
+ {
+ iLog->Log( _L("Incorrect Feature of the device configuration :%s"), KFeature[i].Ptr());
+ Err |= FAIL;
+ }
+ }
+ CleanupStack::PopAndDestroy(output);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+ }
+ CleanupStack::PopAndDestroy(obj);
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::TestDevlon()
+ {
+ _LIT( KExample, "TestDevlon" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ TInt ExpectedValue[KSize]=
+ {
+ ETrue, //KCamera
+ ETrue, //KMemoryCard
+ ETrue, //KFMRadio
+ EFalse, //KQwerty
+ ETrue, //KWLan
+ ETrue, //KUsb
+ ETrue, //KPen
+ EFalse, //KLED
+ EFalse, //KCoverUI
+ ETrue, //KSideVolumeKeys
+ ETrue, //KVibra
+ };
+
+ for(TInt i=0;i<KSize;i++)
+ {
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KFeatures,KFeature[i],output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL feature: %s"),KFeature[i].Ptr() );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data: %s"), KFeature[i].Ptr());
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt IsSupported = ((CStatus*)output)->Status();
+
+ if(IsSupported)
+ {
+ iLog->Log( _L("Feature %s: Supported"), KFeature[i].Ptr());
+ }
+ else
+ {
+ iLog->Log( _L("Feature %s: Not Supported"), KFeature[i].Ptr());
+ }
+
+ if(ExpectedValue[i] != IsSupported)
+ {
+ iLog->Log( _L("Incorrect Feature of the device configuration :%s"), KFeature[i].Ptr());
+ Err |= FAIL;
+ }
+ }
+ CleanupStack::PopAndDestroy(output);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error") );
+ }
+ }
+ CleanupStack::PopAndDestroy(obj);
+ return Err;
+ }
+
+TInt Ctsysinfoservicetests::TestN6290()
+ {
+ _LIT( KExample, "TestN6290" );
+ iLog->Log( KExample );
+ TInt Err(PASS);
+
+ __UHEAP_MARK;
+ CSysInfoService *obj = CSysInfoService::NewL();
+ CleanupStack::PushL(obj);
+
+ TInt ExpectedValue[KSize]=
+ {
+ ETrue, //KCamera
+ ETrue, //KMemoryCard
+ ETrue, //KFMRadio
+ EFalse, //KQwerty
+ EFalse, //KWLan
+ ETrue, //KUsb
+ EFalse, //KPen
+ EFalse, //KLED
+ EFalse, //KCoverUI // but supported need to check.
+ ETrue, //KSideVolumeKeys
+ ETrue, //KVibra
+ };
+
+ for(TInt i=0;i<KSize;i++)
+ {
+ CSysData* output=NULL;
+ TRAPD(err,obj->GetInfoL(KFeatures,KFeature[i],output));
+ if (!err)
+ {
+ if(!output)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL feature: %s"),KFeature[i].Ptr() );
+ }
+ else
+ {
+ CleanupStack::PushL(output);
+ if( CSysData::EStatus != output->DataType() )
+ {
+ iLog->Log( _L("Invalid output data: %s"), KFeature[i].Ptr());
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt IsSupported = ((CStatus*)output)->Status();
+
+ if(IsSupported)
+ {
+ iLog->Log( _L("Feature %s: Supported"), KFeature[i].Ptr());
+ }
+ else
+ {
+ iLog->Log( _L("Feature %s: Not Supported"), KFeature[i].Ptr());
+ }
+
+ if(ExpectedValue[i] != IsSupported)
+ {
+ iLog->Log( _L("Incorrect Feature of the device configuration :%s"), KFeature[i].Ptr());
+ Err |= FAIL;
+ }
+ }
+ CleanupStack::PopAndDestroy(output);
+ }
+ }
+ else
+ {
+ Err |= err;
+ iLog->Log( _L("GetInfo API returned error: %d"),err );
+ }
+ }
+ CleanupStack::PopAndDestroy(obj);
+ return Err;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::VibraStatus
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::VibraStatus(CStifItemParser& /*aItem*/)
+ {
+
+ int ret=0;
+ ret = VibraNotification();
+
+ if(ret==0)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::PredText
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::PredText(CStifItemParser& /*aItem*/)
+ { int ret=0;
+ ret = PredTextNotification();
+
+ if(ret==0)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::InputLang
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::InputLang(CStifItemParser& /*aItem*/)
+ { int ret=0;
+ ret = InputLangNotification();
+
+ if(ret==0)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::GetDisplayLang
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::GetDisplayLang(CStifItemParser& /*aItem*/)
+ {
+
+ TInt result = KErrNone;
+ __UHEAP_MARK;
+
+
+ _LIT( KExample, "GetDisplayLang:" );
+ iLog->Log( KExample );
+
+
+ CSysInfoService* iSysInfoService = CSysInfoService::NewL();
+
+ CleanupStack::PushL(iSysInfoService);
+
+
+ CSysData* data2 = NULL;
+
+ TRAPD(err,iSysInfoService->GetInfoL(KGeneral,KDisplayLanguage,data2));
+ if( err != KErrNotFound )
+ {
+ iLog->Log( _L("Failed,Get Display language found ret err: %d"),err );
+ result = KErrGeneral;
+ }
+ else
+ {
+ result = KErrNone;
+ iLog->Log( _L("Passed Get Display language not found") );
+ }
+
+ delete data2;
+
+ CleanupStack::PopAndDestroy(1);
+ __UHEAP_MARKEND;
+
+ return result;
+
+
+ }
+
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::SetDisplayLang
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::SetDisplayLang(CStifItemParser& /*aItem*/)
+ {
+
+ TInt result = KErrNone;
+
+ __UHEAP_MARK;
+
+ CSysInfoService* iSysInfoService = CSysInfoService::NewL();
+
+ CleanupStack::PushL(iSysInfoService);
+
+
+ CStatus* data = CStatus::NewL(10);
+ CleanupStack::PushL(data);
+ TRAPD(err,iSysInfoService->SetInfoL(KGeneral,KDisplayLanguage,data));
+ if( err != KErrNotFound )
+ {
+ iLog->Log( _L("Failed,Set Display language found ret err: %d"),err );
+ result = KErrGeneral;
+ }
+ else
+ {
+ result = KErrNone;
+ iLog->Log( _L("Passed Set Display language not found") );
+ }
+ CleanupStack::PopAndDestroy(data);
+
+ CSysData *data1 = NULL;
+ TRAPD(err1,iSysInfoService->GetInfoL(KGeneral,KDisplayLanguage,data1));
+ if( err1 != KErrNotFound )
+ {
+ iLog->Log( _L("Failed,Set Display language found ret err: %d"),err );
+ result = KErrGeneral;
+ }
+ else
+ {
+ result = KErrNone;
+ iLog->Log( _L("Passed Set Display language not found") );
+ }
+ delete data1;
+
+ CleanupStack::PopAndDestroy(1);
+ __UHEAP_MARKEND;
+
+ return result;
+
+
+ }
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::SetInputLang
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::SetInputLang(CStifItemParser& /*aItem*/)
+ {
+
+ TInt result = KErrNone;
+ TInt oldInputLang ,newInputLang;
+
+ __UHEAP_MARK;
+
+ CSysInfoService* iSysInfoService = CSysInfoService::NewL();
+
+ CleanupStack::PushL(iSysInfoService);
+
+ CSysData* data1 = NULL;
+
+ TRAPD(err1,iSysInfoService->GetInfoL(KGeneral,KSupportedLanguages,data1));
+ result = err1;
+
+ if(err1 == KErrNone)
+ {
+
+ CSysData* data2 = NULL;
+
+ TRAPD(err2,iSysInfoService->GetInfoL(KGeneral,KInputLanguage,data2));
+ oldInputLang = ((CStatus*)data2)->Status();
+
+ result = err2;
+ if(err2 == KErrNone)
+ {
+
+ for(TInt i=0;i< ((CLanguageList*)data1)->Count() ;i++)
+ {
+ ((CLanguageList*)data1)->At(i,newInputLang);
+ if(newInputLang != oldInputLang)
+ {
+ break;
+ }
+ }
+
+ CStatus* data3 = CStatus::NewL(newInputLang);
+
+ TRAPD(err3,iSysInfoService->SetInfoL(KGeneral,KInputLanguage,data3));
+ TInt changedInputLang = ((CStatus*)data3)->Status();
+ result = err3;
+ if(err3 == KErrNone)
+ {
+ if(newInputLang == changedInputLang)
+ {
+ result = KErrNone;
+ }
+ else
+ {
+ result = KErrGeneral;
+
+ }
+ delete data2;
+ delete data3;
+
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(1);
+ delete data1;
+
+ __UHEAP_MARKEND;
+
+ return result;
+
+
+
+ }
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::SupportedLang
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::SupportedLang(CStifItemParser& /*aItem*/)
+ {
+
+ TInt result = KErrNone;
+ TInt newDisplayLang;
+
+ __UHEAP_MARK;
+
+ _LIT( KExample, "SupportedLang:" );
+ iLog->Log( KExample );
+
+
+ CSysInfoService* iSysInfoService = CSysInfoService::NewL();
+
+ CleanupStack::PushL(iSysInfoService);
+
+ CSysData* data1 = NULL;
+
+ TRAPD(err1,iSysInfoService->GetInfoL(KGeneral,KSupportedLanguages,data1));
+
+ if(err1 == KErrNone)
+ {
+ TInt lang;
+ for(TInt i=0;i< ((CLanguageList*)data1)->Count() ;i++)
+ {
+ ((CLanguageList*)data1)->At(i,lang);
+ TBuf8<50> buf;
+ buf.AppendNum(newDisplayLang);
+ iLog->Log(buf);
+ }
+ }
+ else
+ {
+ iLog->Log(_L("Error GetInfo on supported languages: %d"),err1);
+ }
+
+ result = err1;
+ CleanupStack::PopAndDestroy(1);
+ delete data1;
+
+ __UHEAP_MARKEND;
+
+ return result;
+ }
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::AvailableUSBModes
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt Ctsysinfoservicetests::AvailableUSBModes(CStifItemParser& /*aItem*/)
+ {
+ TInt result = KErrNone;
+ TPtrC usbModes;
+
+ #if (!(defined(__WINS__) || defined(__WINSCW__)))
+
+ __UHEAP_MARK;
+ _LIT( KExample, "AvailableUSBModes:" );
+ iLog->Log( KExample );
+
+ CSysInfoService* iSysInfoService = CSysInfoService::NewL();
+
+ CleanupStack::PushL(iSysInfoService);
+
+
+ CSysData* data1 = NULL;
+
+ TRAPD(err1,iSysInfoService->GetInfoL(KGeneral,KAvailableUSBModes,data1));
+
+ if(err1 == KErrNone)
+ {
+ for(TInt i=0;i< ((CStringList*)data1)->Count() ;i++)
+ {
+ ((CStringList*)data1)->At(i,usbModes);
+ TBuf<50> buf;
+ buf.Copy(usbModes);
+ iLog->Log(buf);
+
+ }
+ }
+ result = err1;
+ CleanupStack::PopAndDestroy(1);
+ delete data1;
+ __UHEAP_MARKEND;
+
+ #endif
+
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::ActiveUSBModes
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::ActiveUSBModes(CStifItemParser& /*aItem*/)
+ {
+ TInt result = KErrNone;
+ TPtrC activeUsbmode;
+
+ #if (!(defined(__WINS__) || defined(__WINSCW__)))
+ __UHEAP_MARK;
+
+ _LIT( KExample, "Active USB Modes:" );
+ iLog->Log( KExample );
+
+
+ CSysInfoService* iSysInfoService = CSysInfoService::NewL();
+
+ CleanupStack::PushL(iSysInfoService);
+
+ CSysData* data1 = NULL;
+
+ TRAPD(err1,iSysInfoService->GetInfoL(KGeneral,KActiveUSBMode,data1));
+
+ if(err1 == KErrNone)
+ {
+ ((CStringData*)data1)->StringData(activeUsbmode);
+ iLog->Log(_L("active usb mode..............."));
+ TBuf<50> mode;
+ mode.Copy(activeUsbmode);
+ iLog->Log(mode);
+
+
+ }
+ CleanupStack::Pop(1);
+ result = err1;
+ delete data1;
+ delete iSysInfoService;
+
+ __UHEAP_MARKEND;
+
+ #endif
+ return result;
+ }
+
+
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::ConnectedAcc
+//
+// -----------------------------------------------------------------------------
+//
+
+TInt Ctsysinfoservicetests::ConnectedAcc(CStifItemParser& /*aItem*/)
+ {
+ TInt result = 0;
+ TPtrC usbModes;
+ // On Emulator this is not supported.
+ #if (! (defined(__WINS__) || defined(__WINSCW__)) )
+
+ __UHEAP_MARK;
+
+ _LIT( KExample, "Connected Accessories:" );
+ iLog->Log( KExample );
+
+
+ CSysInfoService* iSysInfoService = CSysInfoService::NewL();
+
+ CleanupStack::PushL(iSysInfoService);
+
+
+ CSysData* data1 = NULL;
+
+ const CAccessoryInfo* accInfo= NULL;
+
+ TRAPD(err1,iSysInfoService->GetInfoL(KGeneral,KConnectedAccessories,data1));
+
+ if(err1 == KErrNone)
+ {
+ for(TInt i=0;i< ((CAccList*)data1)->Count() ;i++)
+ {
+ ((CAccList*)data1)->AtL(i,accInfo);
+ TBuf8<50> acctype ;
+ TBuf8<50> accConnState;
+ acctype.AppendNum( accInfo->AccessoryType() );
+ accConnState.AppendNum( accInfo->ConnectionState() );
+ iLog->Log(_L("Accessory Type:"));
+ iLog->Log(acctype);
+
+ iLog->Log(_L("Accessory Connection State:"));
+ iLog->Log(accConnState);
+
+
+
+ }
+ }
+ result = err1;
+ CleanupStack::PopAndDestroy(1);
+ delete data1;
+
+ __UHEAP_MARKEND;
+ #endif
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// Ctsysinfoservicetests::VibraNotificationCancel
+//
+// -----------------------------------------------------------------------------
+//
+TInt Ctsysinfoservicetests::NotificationCancelVibra(CStifItemParser& /*aItem*/)
+ {
+
+ int ret=0;
+ ret = VibraNotificationCancel();
+
+ if(ret==0)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+
+
+TInt Ctsysinfoservicetests::ConnBluetooth(CStifItemParser& /*aItem*/)
+ { int ret=0;
+ ret = ReqNotification(0, NULL);
+
+ if(ret==0)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+
+TInt Ctsysinfoservicetests::IRStatus(CStifItemParser& /*aItem*/)
+ { int ret=0;
+ ret = IRNotification(0, NULL);
+
+ if(ret==0)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+
+TInt Ctsysinfoservicetests::GetActiveConnections(CStifItemParser& /*aItem*/)
+ {
+ _LIT( KExample, "GetActiveConnections" );
+ iLog->Log( KExample );
+
+ int ret=0;
+ ret = ActiveConnection(iLog);
+
+ if(ret==0)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+
+
+TInt Ctsysinfoservicetests::GetWlanMacAddress(CStifItemParser& /*aItem*/)
+ {
+ int ret=0;
+
+ #if (!(defined(__WINS__) || defined(__WINSCW__)))
+ TInt Err(PASS);
+
+ _LIT( KExample, "GetWlanMacAddress" );
+ iLog->Log( KExample );
+ TPtrC wlanAddress;
+
+ CSysInfoService* iSysInfoService = CSysInfoService::NewL();
+
+ CleanupStack::PushL(iSysInfoService);
+ CSysData* data2 = NULL;
+
+ TRAPD(err1,iSysInfoService->GetInfoL(KFeatures,KWLan,data2));
+ if (!err1)
+ {
+ if(!data2)
+ {
+ Err |= FAIL;
+ iLog->Log( _L("Output data Set to NULL feature: %s"),KWLan );
+ }
+ else
+ {
+ CleanupStack::PushL(data2);
+ if( CSysData::EStatus != data2->DataType() )
+ {
+ iLog->Log( _L("Invalid output data: %s"), KWLan);
+ Err |= FAIL;
+ }
+ else
+ {
+ TInt IsSupported = ((CStatus*)data2)->Status();
+
+ if(IsSupported)
+ {
+ CSysData* data1 = NULL;
+
+ TRAPD(err1,iSysInfoService->GetInfoL(KConnectivity,KWLanMacAddress,data1));
+ ret = err1;
+ if(err1 == KErrNone)
+ {
+ ((CStringData*)data1)->StringData(wlanAddress);
+
+ iLog->Log(_L("WlanMacAddress:"));
+ TBuf8<50> buf;
+ buf.Copy(wlanAddress);
+ iLog->Log(buf);
+
+ }
+ else
+ {
+ iLog->Log(_L("Error reading: %d"),err1);
+ }
+ delete data1;
+ }
+ }
+ CleanupStack::Pop(1);
+ }
+ }
+ delete data2;
+ CleanupStack::PopAndDestroy(1);
+
+ #endif
+ return ret;
+
+ }
+
+
+TInt Ctsysinfoservicetests::GetActiveConnectionsCancel(CStifItemParser& /*aItem*/)
+ {
+
+ _LIT( KExample, "ConnNotification" );
+ iLog->Log( KExample );
+
+ int ret=0;
+ ret = GetActiveConnReqCancel();
+
+ if(ret==0)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+
+
+