--- /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 <e32cmn.h>
+#include <e32debug.h>
+
+#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 );
+ }
+