diff -r eaaed528d5fd -r 320d509f1a12 usbmgmt/usbmgrtest/t_usb_charging/src/usbchargingarmtest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgrtest/t_usb_charging/src/usbchargingarmtest.cpp Mon Oct 04 03:06:48 2010 +0300 @@ -0,0 +1,381 @@ +/* +* Copyright (c) 2006-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: +* +*/ + +#include +#include + +#include "usbchargingarmtest.h" +#include "usbchargingpublishedinfo.h" +#include "testmanager.h" +#include "usbstatewatcher.h" +#include "usbchargingcurrentwatcher.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "usbchargingarmtestTraces.h" +#endif + +_LIT(KMsFsy, "MSFS.FSY"); + + +CUsbChargingArmTest::CUsbChargingArmTest(MTestManager& aManager) + : CTestBase(aManager) + { + OstTraceFunctionEntry0( DUP1_CUSBCHARGINGARMTEST_CUSBCHARGINGARMTEST_ENTRY ); + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_CUSBCHARGINGARMTEST_ENTRY ); + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_CUSBCHARGINGARMTEST_EXIT ); + OstTraceFunctionExit0( DUP1_CUSBCHARGINGARMTEST_CUSBCHARGINGARMTEST_EXIT ); + } + +CTestBase* CUsbChargingArmTest::NewL(MTestManager& aManager) + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_NEWL_ENTRY ); + CUsbChargingArmTest* self = new(ELeave) CUsbChargingArmTest(aManager); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_NEWL_EXIT ); + return self; + } + + +int CUsbChargingArmTest::StartMassStorage() + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_STARTMASSSTORAGE_ENTRY ); + TInt r = KErrNone; + OstTrace0( TRACE_NORMAL, CUSBCHARGINGARMTEST_STARTMASSSTORAGE, "CUsbChargingArmTest::StartMassStorage AddFileSystem" ); + iManager.Write(_L8("Start Mass Storage")); + r = iFs.Connect(); + if (r != KErrNone) + { + OstTrace0( TRACE_ERROR, DUP1_CUSBCHARGINGARMTEST_STARTMASSSTORAGE, "CUsbChargingArmTest::StartMassStorage Connect to fs failed" ); + iManager.Write(_L8("Connect to Fs failed")); + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_STARTMASSSTORAGE_EXIT ); + return r; + } + r = iFs.AddFileSystem(KMsFsy); + if (r != KErrNone) + { + OstTrace0( TRACE_ERROR, DUP2_CUSBCHARGINGARMTEST_STARTMASSSTORAGE, "CUsbChargingArmTest::StartMassStorage AddFileSystem failed" ); + iManager.Write(_L8("AddFileSystem failed")); + OstTraceFunctionExit0( DUP1_CUSBCHARGINGARMTEST_STARTMASSSTORAGE_EXIT ); + return r; + } + + OstTrace0( TRACE_NORMAL, DUP3_CUSBCHARGINGARMTEST_STARTMASSSTORAGE, "CUsbChargingArmTest::StartMassStorage AddFileSystem success" ); + iManager.Write(_L8("AddFileSystem success")); + OstTraceFunctionExit0( DUP3_CUSBCHARGINGARMTEST_STARTMASSSTORAGE_EXIT ); + return r; + } + + +void CUsbChargingArmTest::ConstructL() + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_CONSTRUCTL_ENTRY ); + TInt res; + res = StartMassStorage(); + if(res != KErrNone) + { + iManager.Write(_L8("start KMsFsy failed")); + return; + } + else + { + iManager.Write(_L8("start KMsFsy success")); + } + + // -- Insert initialization code here + iManager.Write(_L8("About to connect to USBMan")); + res = iUsbMan.Connect(); + if(res != KErrNone) + { + iManager.Write(_L8("Connection to USBMan failed")); + return; + } + else + { + iManager.Write(_L8("Cconnected to USBMan success")); + } + iChargingCurrentWatcher = CUsbChargingCurrentWatcher::NewL(*this); + +#ifndef COMMANDLINE_PARAM + iManager.Write(_L8("About to Set Control session")); + res = iUsbMan.SetCtlSessionMode(ETrue); + if(res != KErrNone) + { + iManager.Write(_L8("Set Control session failed")); + return; + } + else + { + iManager.Write(_L8("Set Control session Success")); + } + + iManager.Write(_L8("About to start USBMan")); + TRequestStatus requestStatus; + iUsbMan.TryStart(1, requestStatus); + User::WaitForRequest(requestStatus); + if(requestStatus.Int() == KErrNone) + { + iManager.Write(_L8("USBMan Started Success")); + iUsbStateWatcher = CUsbStateWatcher::NewL(*this); + } + else + { + iManager.Write(_L8("Failed to start USBMan")); + } +#endif + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_CONSTRUCTL_EXIT ); + } + +CUsbChargingArmTest::~CUsbChargingArmTest() + { + OstTraceFunctionEntry0( DUP2_CUSBCHARGINGARMTEST_CUSBCHARGINGARMTEST_ENTRY ); + + // -- Insert cleanup code here + delete iChargingCurrentWatcher; + delete iUsbStateWatcher; + iUsbMan.Close(); + iFs.Close(); + OstTraceFunctionExit0( DUP2_CUSBCHARGINGARMTEST_CUSBCHARGINGARMTEST_EXIT ); + } + +void CUsbChargingArmTest::ProcessKeyL(TKeyCode aKeyCode) + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_PROCESSKEYL_ENTRY ); + TInt res; + iManager.Write(_L8("CUsbChargingArmTest::ProcessKeyL")); + + switch ( aKeyCode ) + { + case '1': + { + iManager.Write(_L8("About to Set Control session")); + res = iUsbMan.SetCtlSessionMode(ETrue); + if(res != KErrNone) + { + iManager.Write(_L8("Set Control session failed")); + return; + } + else + { + iManager.Write(_L8("Set Control session Success")); + } + + iManager.Write(_L8("About to start USBMan")); + TRequestStatus requestStatus; + iUsbMan.Start(requestStatus); + User::WaitForRequest(requestStatus); + if(requestStatus.Int() == KErrNone) + { + iManager.Write(_L8("USBMan Started OK")); + if(!iChargingCurrentWatcher) + { + iChargingCurrentWatcher = CUsbChargingCurrentWatcher::NewL(*this); + } + if(!iUsbStateWatcher) + { + iUsbStateWatcher = CUsbStateWatcher::NewL(*this); + } + } + else + { + iManager.Write(_L8("Failed to start USBMan")); + } + } + break; + case '2': + { + iManager.Write(_L8("About to stop USBMan")); + TRequestStatus requestStatus; + iUsbMan.Stop(requestStatus); + User::WaitForRequest(requestStatus); + if(requestStatus.Int() == KErrNone) + { + iManager.Write(_L8("USBMan Stopped OK")); + } + else + { + iManager.Write(_L8("Failed to stop USBMan")); + } + } + break; + + + default: + iManager.Write(_L8("Unknown selection")); + break; + } + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_PROCESSKEYL_EXIT ); + } + +void CUsbChargingArmTest::DisplayTestSpecificMenu() + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_DISPLAYTESTSPECIFICMENU_ENTRY ); + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_DISPLAYTESTSPECIFICMENU_EXIT ); + } + +void CUsbChargingArmTest::ShowUsbChargingValue(TPublishedUsbChargingInfo& aValue) + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_ENTRY ); + iManager.Write(_L8("=====Published Current Info=====")); + ShowChargingType(aValue.iChargingPortType); + ShowConnStatus(aValue.iUsbConnStatus); + iManager.Write(_L8("MinAvailableVbusCurrent : %d"), aValue.iMinAvailableVbusCurrent); + iManager.Write(_L8("MaxVbusCurrent : %d"), aValue.iMaxVbusCurrent); + iManager.Write(_L8("MinVbusVoltage : %d"), aValue.iMinVbusVoltage); + iManager.Write(_L8("===Published Current Info End===")); + + OstTrace0( TRACE_NORMAL, CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_DUP1, "CUsbChargingArmTest::ShowUsbChargingValue =====Published Current Info=====" ); + OstTrace1( TRACE_NORMAL, CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_DUP2, "CUsbChargingArmTest::ShowUsbChargingValue;aValue.iChargingPortType=%d", aValue.iChargingPortType ); + OstTrace1( TRACE_NORMAL, CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_DUP3, "CUsbChargingArmTest::ShowUsbChargingValue;aValue.iUsbConnStatus=%d", aValue.iUsbConnStatus ); + OstTrace1( TRACE_NORMAL, CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_DUP4, "CUsbChargingArmTest::ShowUsbChargingValue;aValue.iMinAvailableVbusCurrent=%u", aValue.iMinAvailableVbusCurrent ); + OstTrace1( TRACE_NORMAL, CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_DUP5, "CUsbChargingArmTest::ShowUsbChargingValue;aValue.iMaxVbusCurrent=%u", aValue.iMaxVbusCurrent ); + OstTrace1( TRACE_NORMAL, CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_DUP6, "CUsbChargingArmTest::ShowUsbChargingValue;aValue.iMinVbusVoltage=%u", aValue.iMinVbusVoltage ); + OstTrace0( TRACE_NORMAL, CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_DUP7, "CUsbChargingArmTest::ShowUsbChargingValue ===Published Current Info End===" ); + + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_SHOWUSBCHARGINGVALUE_EXIT ); + } + +void CUsbChargingArmTest::ShowUsbDeviceState(TUsbDeviceState aDeviceState) + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_SHOWUSBDEVICESTATE_ENTRY ); + TPtrC res(NULL, 0); + + _LIT(KUndefined, "Undefined"); + _LIT(KDefault, "Default"); + _LIT(KAttached, "Attached"); + _LIT(KPowered, "Powered"); + _LIT(KConfigured, "Configured"); + _LIT(KAddress, "Address"); + _LIT(KSuspended, "Suspended"); + _LIT(KUnKnown, "UnKnown"); + + switch(aDeviceState) + { + case EUsbDeviceStateUndefined: + res.Set(KUndefined); + break; + case EUsbDeviceStateDefault: + res.Set(KDefault); + break; + case EUsbDeviceStateAttached: + res.Set(KAttached); + break; + case EUsbDeviceStatePowered: + res.Set(KPowered); + break; + case EUsbDeviceStateConfigured: + res.Set(KConfigured); + break; + case EUsbDeviceStateAddress: + res.Set(KAddress); + break; + case EUsbDeviceStateSuspended: + res.Set(KSuspended); + break; + default: + res.Set(KUnKnown); + break; + } + + iManager.Write(_L8("USBDevice State is: %S"), &res); + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_SHOWUSBDEVICESTATE_EXIT ); + } + +void CUsbChargingArmTest::ShowChargingType(TUsbChargingPortType aChargingType) + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_SHOWCHARGINGTYPE_ENTRY ); + TPtrC res(NULL, 0); + + _LIT(KPortTypeNone, "None"); + _LIT(KPortTypeUnsupported, "Unsupported"); + _LIT(KPortTypeChargingPort, "ChargingPort"); + _LIT(KPortTypeDedicatedChargingPort, "DedicatedChargingPort"); + _LIT(KPortTypeStandardDownstreamPort, "StandardDownstreamPort"); + _LIT(KPortTypeChargingDownstreamPort, "ChargingDownstreamPort"); + _LIT(KPortTypeAcaRidA, "RidAAca"); + _LIT(KPortTypeAcaRidB, "RidBAca"); + _LIT(KPortTypeAcaRidC, "RidCAca"); + _LIT(KUnKnown, "UnKnown"); + + switch (aChargingType) + { + case EUsbChargingPortTypeNone: + res.Set(KPortTypeNone); + break; + case EUsbChargingPortTypeUnsupported: + res.Set(KPortTypeUnsupported); + break; + case EUsbChargingPortTypeChargingPort: + res.Set(KPortTypeChargingPort); + break; + case EUsbChargingPortTypeDedicatedChargingPort: + res.Set(KPortTypeDedicatedChargingPort); + break; + case EUsbChargingPortTypeChargingDownstreamPort: + res.Set(KPortTypeChargingDownstreamPort); + break; + case EUsbChargingPortTypeStandardDownstreamPort: + res.Set(KPortTypeStandardDownstreamPort); + break; + case EUsbChargingPortTypeAcaRidA: + res.Set(KPortTypeAcaRidA); + break; + case EUsbChargingPortTypeAcaRidB: + res.Set(KPortTypeAcaRidB); + break; + case EUsbChargingPortTypeAcaRidC: + res.Set(KPortTypeAcaRidC); + break; + default: + res.Set(KUnKnown); + break; + } + iManager.Write(_L8("ChargingPortType: %S"), &res); + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_SHOWCHARGINGTYPE_EXIT ); + } + +void CUsbChargingArmTest::ShowConnStatus(TUsbConnectionStatus aStatus) + { + OstTraceFunctionEntry0( CUSBCHARGINGARMTEST_SHOWCONNSTATUS_ENTRY ); + TPtrC res(NULL, 0); + + _LIT(KNone, "None"); + _LIT(KConfigured, "Configured"); + _LIT(KSuspended, "Suspend"); + _LIT(KUnKnown, "UnKnown"); + + switch(aStatus) + { + case EUsbConnectionStatusNone: + res.Set(KNone); + break; + case EUsbConnectionStatusSuspend: + res.Set(KSuspended); + break; + case EUsbConnectionStatusConfigured: + res.Set(KConfigured); + break; + default: + res.Set(KUnKnown); + break; + } + + iManager.Write(_L8("ConnectionStatus: %S"), &res); + OstTraceFunctionExit0( CUSBCHARGINGARMTEST_SHOWCONNSTATUS_EXIT ); + } +