/*
* 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 );
}