FCL/sf/mw/usbservices: comparison usbengines/usbotgwatcher/src/cusbotgwatcher.cpp

equal deleted inserted replaced

-:8ecef05bbada
+:a44cdf4b4bf0
 /*
 * Copyright (c) 2008-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:  Implementation
 *
-*/
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  Implementation
+*
+*/
 #include <usbpersonalityids.h>
 #include <usbuinotif.h>
 #include <UsbWatcherInternalPSKeys.h>
 #include "cusbotgwatcher.h"
 #include "cusbstate.h"
 #include "cusbstatehostainitiate.h"
 #include "cusbstatehostahost.h"
 #include "cusbstatehostaperipheral.h"
-#include "cusbstatehostaidle.h"
 #include "cusbstatehosthandle.h"
 #include "cusbstatehostdelayhandle.h"
+#include "cusbstatehostdelayattachedhandle.h"
+#include "cusbstatehostdelaynotattachedhandle.h"
+#include "cusbstatehosthandledropping.h"
 #include "cusbstatehostundefined.h"
 #include "cusbwarningnotifier.h"
 #ifndef STIF
 #include "cusbnotifmanager.h"
 #else
 #include "mockcusbnotifmanager.h"
 #endif
 #include "errors.h"
 #include "debug.h"
 #include "panic.h"
 _LIT_SECURITY_POLICY_PASS( KAlwaysPassPolicy );
 _LIT_SECURITY_POLICY_C1( KLocalServicesPolicy, ECapabilityLocalServices );
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 CUsbOtgWatcher::CUsbOtgWatcher(RUsb& aUsbMan) :
-iUsb(aUsbMan), iPersonalityId(KUsbPersonalityIdMTP)
+iUsb(aUsbMan), iPersonalityId(KUsbPersonalityIdMTP), iUsbServiceRequest(
-{
+CUsbServiceControl::ERequestUndefined)
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::CUsbOtgWatcher" ) );
+{
+LOG_FUNC
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::ConstructL()
 {
+LOG_FUNC
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::ConstructL" ) );
 #ifdef _DEBUG
 SelfTestL();
 #endif
 #ifndef STIF
-User::LeaveIfError(RProperty::Define( KPSUidUsbWatcher,
+User::LeaveIfError(RProperty::Define(KPSUidUsbWatcher,
-KUsbWatcherIsPeripheralConnected, RProperty::EInt, KAlwaysPassPolicy,
+KUsbWatcherIsPeripheralConnected, RProperty::EInt,
-KLocalServicesPolicy ) );
+KAlwaysPassPolicy, KLocalServicesPolicy));
-User::LeaveIfError( RProperty::Set( KPSUidUsbWatcher,
+User::LeaveIfError(RProperty::Set(KPSUidUsbWatcher,
 KUsbWatcherIsPeripheralConnected,
-KUsbWatcherPeripheralIsNotConnected ) );
+KUsbWatcherPeripheralIsNotConnected));
 #endif
-iUsbServiceControl = CUsbServiceControl::NewL(this, iUsb);
+iUsbServiceControl = CUsbServiceControl::NewL(*this, iUsb);
-User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL(
-User::LeaveIfError(iStates.Append(CUsbStateHostDelayHandle::NewL(this)));
+*this)));
+User::LeaveIfError(iStates.Append(
+CUsbStateHostDelayNotAttachedHandle::NewL(*this)));
+User::LeaveIfError(iStates.Append(
+CUsbStateHostHandleDropping::NewL(*this)));
 iIdPinObserver = CUsbIdPinObserver::NewL();
 iVBusObserver = CUsbVBusObserver::NewL();
 iOtgStateObserver = CUsbOtgStateObserver::NewL();
 iBusActivityObserver = CUsbBusActivityObserver::NewL();
 iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL(
 &iUsb);
 iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL(
 &iUsb);
 iHostState = iStates[EUsbStateHostUndefined];
 // Notif manager must be created at least after VBus observer and iHostState initialization
 // to allow USb indicator subscribe to its notifications at construction and check their's current states
-iNotifManager = CUsbNotifManager::NewL(this);
+iNotifManager = CUsbNotifManager::NewL(*this);
 iVBusObserver->SubscribeL(*this);
 iOtgStateObserver->SubscribeL(*this);
 iBusActivityObserver->SubscribeL(*this);
 iHostEventNotificationObserver->SubscribeL(*this);
 //
 // ---------------------------------------------------------------------------
 //
 EXPORT_C CUsbOtgWatcher* CUsbOtgWatcher::NewL(RUsb& aUsbMan)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::NewL" ) );
+LOG_FUNC
 CUsbOtgWatcher* self = new (ELeave) CUsbOtgWatcher(aUsbMan);
 CleanupStack::PushL(self);
 self->ConstructL();
 CleanupStack::Pop(self);
 //
 // ---------------------------------------------------------------------------
 //
 CUsbOtgWatcher::~CUsbOtgWatcher()
 {
-		FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::~CUsbOtgWatcher" ) );
+LOG_FUNC
 #ifndef STIF
-RProperty::Delete( KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected );
+RProperty::Delete(KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected);
 #endif
 // delete Notif manager before VBus observer, due to USB indicator observes VBus
 delete iNotifManager;
-if(iIdPinObserver)
+if (iIdPinObserver)
 {
 TRAP_IGNORE(iIdPinObserver->UnsubscribeL(*this));
 }
-if(iVBusObserver)
+if (iVBusObserver)
 {
 TRAP_IGNORE(iVBusObserver->UnsubscribeL(*this));
 }
-if(iOtgStateObserver)
+if (iOtgStateObserver)
 {
 TRAP_IGNORE(iOtgStateObserver->UnsubscribeL(*this));
 }
-if(iBusActivityObserver)
+if (iBusActivityObserver)
 {
 TRAP_IGNORE(iBusActivityObserver->UnsubscribeL(*this));
 }
-if(iHostEventNotificationObserver)
+if (iHostEventNotificationObserver)
 {
 TRAP_IGNORE(iHostEventNotificationObserver->UnsubscribeL(*this));
 }
-if(iMessageNotificationObserver)
+if (iMessageNotificationObserver)
 {
 TRAP_IGNORE(iMessageNotificationObserver->UnsubscribeL(*this));
 }
 delete iIdPinObserver;
 delete iVBusObserver;
 delete iOtgStateObserver;
 delete iBusActivityObserver;
 delete iHostEventNotificationObserver;
 delete iMessageNotificationObserver;
 iOtgStateObservers.Close();
 // Destroy states
 iStates.ResetAndDestroy();
 iStates.Close();
 delete iUsbServiceControl;
 iUsb.Close();
 }
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SetPersonalityL(TRequestStatus& /*aStatus*/,
 TInt aPersonality)
 {
+LOG_FUNC
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPersonalityL aPersonality = %d" ), aPersonality));
+LOG1( "aPersonality = %d" , aPersonality);
 // watcher keeps this value, no need to pass it to request object
 // state can read it from watcher when needed
 iPersonalityId = aPersonality;
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::CancelSetPersonalityL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::CancelSetPersonalityL" ) );
+LOG_FUNC
 iState->CancelSetPersonalityL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SetPreviousPersonalityL(TRequestStatus& /*aStatus*/)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPreviousPersonalityL" ) );
+LOG_FUNC
 // maybe more complex processing needed here
 iState->SetPreviousPersonalityL();
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SetPreviousPersonalityL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPreviousPersonalityL" ) );
+LOG_FUNC
 iState->SetPreviousPersonalityL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::CancelSetPreviousPersonalityL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::CancelSetPreviousPersonalityL" ) );
+LOG_FUNC
 iState->CancelSetPreviousPersonalityL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SetPreviousPreviousPersonalityOnDisconnectL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPreviousPreviousPersonalityOnDisconnectL" ) );
+LOG_FUNC
 }
 // From IdPin observer
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::StartSessionL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL" ) );
+LOG_FUNC
 if (!CanStartSessionL())
 {
-HandleHostProblemL(EUsbWatcherErrorInConnection, EUsbStateHostHandle);
+HandleHostProblemL(EUsbWatcherCanNotStartSession,
+EUsbStateHostHandleDropping);
 return;
 }
+iUsbServiceRequest = CUsbServiceControl::EStartUsbService;
 TInt err = iUsbServiceControl->StartL(iPersonalityId);
 if (KErrNone != err)
 {
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL Can not start usb services. reason = %d" ), err));
+LOG1( "Can not start usb services. err = %d" , err);
-HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle);
+HandleHostProblemL(EUsbWatcherCanNotStartUsbServices,
+EUsbStateHostHandleDropping);
 return;
 }
 // call back from iUsbServiceControl->Start(iPersonalityId) call is UsbServiceControlReqCompletedL(TInt aError)
 // so, continue there if everything is OK
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf, TUsbStateIds aInState )
+void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf,
-{
+TUsbStateIds aInState)
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HandleProblemL" ) );
+{
+LOG_FUNC
 HostHandle(aInState)->SetWhat(aWhatKindOf);
 ChangeHostStateL(aInState);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::IdPinOnL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOnL" ) );
+LOG_FUNC
 StartSessionL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::IdPinOffL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL" ) );
+LOG_FUNC
 ChangeHostStateL(EUsbStateHostUndefined);
 iNotifManager->CloseAllNotifiers();
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL Before DisableFunctionDriverLoad " ) );
 Usb().DisableFunctionDriverLoading();
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL Before TryStop" ) );
+iUsbServiceRequest = CUsbServiceControl::EStopUsbService;
 TInt err = iUsbServiceControl->StopL();
+LOG1( "iUsbServiceControl->Stop() err = %d", err );
 if (KErrNone != err)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOnL ErrorStoppingUsbServices" ) );
+LOG( "ErrorStoppingUsbServices" );
 Panic(ECanNotStopUsbServices);
 }
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL iUsbServiceControl->Stop() OK" ) );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::IdPinErrorL(TInt aError)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinErrorL" ) );
+__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+HandleHostProblemL(EUsbWatcherIdPinError, EUsbStateHostHandleDropping);
-HandleHostProblemL(EUsbWatcherIdPinError, EUsbStateHostHandle);
 }
 // From VBus observer
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::VBusDownL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusDownL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->VBusDownL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::VBusUpL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusUpL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->VBusUpL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::VBusObserverErrorL(TInt aError)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusObserverErrorL" ) );
+__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+HandleHostProblemL(EUsbWatcherVBusObserverError,
-HandleHostProblemL(EUsbWatcherVBusObserverError, EUsbStateHostHandle);
+EUsbStateHostHandleDropping);
 }
 // From OTG state observer
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::AIdleL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AIdleL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->AIdleL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::AHostL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AHostL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->AHostL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::APeripheralL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::APeripheralL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->APeripheralL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::AVBusErrorL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AVBusErrorL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->AVBusErrorL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BIdleL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BIdleL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->BIdleL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BPeripheralL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BPeripheralL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->BPeripheralL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BHostL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BHostL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->BHostL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::OtgStateErrorL(TInt aError)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::OtgStateErrorL" ) );
+__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+HandleHostProblemL(EUsbWatcherOtgStateError, EUsbStateHostHandleDropping);
-HandleHostProblemL(EUsbWatcherOtgStateError, EUsbStateHostHandle);
 }
 // From bus activity observer
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BusIdleL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusIdleL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->BusIdleL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BusActiveL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusActiveL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->BusActiveL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BusActivityErrorL(TInt aError)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusActivityErrorL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 // no action, continue
 }
 // From Host Event notification observer
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DeviceAttachedL(TDeviceEventInformation aTdi)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DeviceAttachedL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->DeviceAttachedL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DeviceDetachedL(TDeviceEventInformation aTdi)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DeviceDetachedL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->DeviceDetachedL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DriverLoadSuccessL(TDeviceEventInformation aTdi)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DriverLoadSuccessL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->DriverLoadSuccessL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DriverLoadPartialSuccessL(TDeviceEventInformation aTdi)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DriverLoadPartialSuccessL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->DriverLoadPartialSuccessL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DriverLoadFailureL(TDeviceEventInformation aTdi)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DriverLoadFailureL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->DriverLoadFailureL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::HostEventNotificationErrorL(TInt aError)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HostEventNotificationErrorL" ) );
+__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+HandleHostProblemL(EUsbWatcherHostEventNotificationError,
-HandleHostProblemL(EUsbWatcherHostEventNotificationError, EUsbStateHostHandle);
+EUsbStateHostHandleDropping);
 }
 // From message notification observer
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::MessageNotificationReceivedL(TInt aMessage)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::MessageNotificationReceivedL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->MessageNotificationReceivedL(aMessage);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BadHubPositionL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BadHubPositionL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->BadHubPositionL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::VBusErrorL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusErrorL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->VBusErrorL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SrpReceivedL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SrpReceivedL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->SrpReceivedL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SessionRequestedL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SessionRequestedL" ) );
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
 iHostState->SessionRequestedL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::MessageNotificationErrorL(TInt aError)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::MessageNotificationErrorL" ) );
+__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+HandleHostProblemL(EUsbWatcherMessageNotificationError,
-HandleHostProblemL(EUsbWatcherMessageNotificationError, EUsbStateHostHandle);
+EUsbStateHostHandleDropping);
 }
 // ---------------------------------------------------------------------------
 // getters
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 CUsbStateHostHandle* CUsbOtgWatcher::HostHandle(TUsbStateIds aInState) const
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HostHandle" ) );
 __ASSERT_DEBUG(iStates[aInState] != NULL, Panic(EBadState));
 return (CUsbStateHostHandle*) iStates[aInState];
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::ChangeStateL(TUsbStateIds aNewStateId)
 {
+LOG_FUNC
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::ChangeStateL aNewState = %d" ), aNewStateId));
+LOG1( "aNewState = %d" , aNewStateId);
 if (NULL != iState)
 {
-if (aNewStateId == iState->Id())
+iState->JustBeforeLeavingThisStateL();
-{
-return; // we already in the target state
-}
-else
-{
-iState->JustBeforeLeavingThisStateL();
-}
 }
 // sets new state
 // be careful to add states into States in exactly the same order as they enumerated
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::ChangeHostStateL(TUsbStateIds aNewStateId)
 {
+LOG_FUNC
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::ChangeHostStateL aNewState = %d" ), aNewStateId));
+LOG1( "aNewState = %d", aNewStateId);
 if (NULL != iHostState)
 {
-if (aNewStateId == iHostState->Id())
+iHostState->JustBeforeLeavingThisStateL();
-{
-return; // we already in the target state
-}
-else
-{
-iHostState->JustBeforeLeavingThisStateL();
-}
 }
 // set new state
 // be careful to add states into States in exactly the same order as they enumerated
 iHostState = iStates[aNewStateId];
 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadState));
 iHostState->JustAdvancedToThisStateL(); // checks if there are conditions for advancing to another state(s)
 // notify state change to observers
 for (TInt i(0); i < iOtgStateObservers.Count(); ++i)
 {
 iOtgStateObservers[i]->OtgWatcherStateChangedL(iHostState->Id());
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::PrintStateToLog()
 {
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::PrintStateToLog IdPin       = %d" ), iIdPinObserver->IdPin()));
+LOG1( "Current state id  = %d" , iHostState->Id());
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::PrintStateToLog VBus        = %d" ), iVBusObserver->VBus()));
+LOG1( "IdPin             = %d" , iIdPinObserver->IdPin());
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::PrintStateToLog OtgState    = %d" ), iOtgStateObserver->OtgState()));
+LOG1( "VBus              = %d" , iVBusObserver->VBus());
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::PrintStateToLog BusActivity = %d" ), iBusActivityObserver->BusActivity()));
+LOG1( "OtgState          = %d" , iOtgStateObserver->OtgState());
+LOG1( "BusActivity       = %d" , iBusActivityObserver->BusActivity());
-TInt isPeripheralConnected(KUsbWatcherPeripheralIsNotConnected);
+TInt isPeripheralConnected(KUsbWatcherPeripheralIsNotConnected);
-RProperty::Get( KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected,
-isPeripheralConnected  );
+RProperty::Get(KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected,
+isPeripheralConnected);
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::PrintStateToLog IsPeripheralConnected = %d" ), isPeripheralConnected));
+LOG1( "IsPeripheralConnected = %d" , isPeripheralConnected);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::UsbServiceControlReqCompletedL(TInt aError)
 {
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompleted Error returned by UsbServiceControl = %d" ), aError));
+LOG_FUNC
-switch(aError)
+LOG1( "aError = %d" , aError);
-{
-case KErrInUse:
+switch (aError)
-// usb services already started (this might happen if more than one idpin on event come)
+{
-{
+case KErrInUse:
-return;
+// usb services already started (this might happen if more than one idpin on event come)
-}
-case KErrNone:
-{
-break; // do normal routine
-}
-default: // handle the issue
-{
-if(IsDeviceA()) // if there is no cable, give up
 {
-HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle);
+return;
 }
-return;
-}
+case KErrNone:
-}
+{
+break; // do normal routine
+}
+default: // handle the issue
+{
+if (iUsbServiceRequest == CUsbServiceControl::EStartUsbService) // Handle only start issues
+{
+HandleHostProblemL(EUsbWatcherCanNotStartUsbServices,
+EUsbStateHostHandleDropping);
+}
+iUsbServiceRequest = CUsbServiceControl::ERequestUndefined;
+return;
+}
+}
+iUsbServiceRequest = CUsbServiceControl::ERequestUndefined;
 TUsbServiceState serviceState;
 TInt err = iUsb.GetServiceState(serviceState);
 if (KErrNone != err)
 {
-FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompleted Error when requesting GetServiceState = %d" ), err));
+LOG1( "Error when requesting GetServiceState = %d" , err);
-HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle);
+HandleHostProblemL(EUsbWatcherCanNotStartUsbServices,
+EUsbStateHostHandleDropping);
 return;
 }
 switch (serviceState)
 {
 case EUsbServiceIdle: // just stopped usb service
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceIdle" ) );
+LOG("UsbServiceState == EUsbServiceIdle" );
 // do nothing
 break;
 }
 case EUsbServiceStarted: // just started usb service
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStarted" ) );
+LOG( "UsbServiceState == EUsbServiceStarted" );
-iHostState = iStates[EUsbStateHostAInitiate];
+ChangeHostStateL(EUsbStateHostAInitiate);
-iHostState->JustAdvancedToThisStateL(); // do any initial activity, once advanced to the state
 break;
 }
 case EUsbServiceStarting:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStarting" ) );
+LOG("UsbServiceState == EUsbServiceStarting" );
 // should not receive that, due to call back is called when service stopped or started
 // therefore scream
 // no break statement here
 }
 case EUsbServiceStopping:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStopping" ) );
+LOG("UsbServiceState == EUsbServiceStopping" );
 // should not receive that, due to call back is called when service stopped or started
 // therefore scream
 // no break statement here
 }
 case EUsbServiceFatalError:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceFatalError" ) );
+LOG( "UsbServiceState == EUsbServiceFatalError" );
 Panic(EUnexpectedUsbServiceState);
 break;
 }
 default:
 {
 Panic(EUnknownUsbServiceState);
 }
 }
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TInt CUsbOtgWatcher::SelfTestL()
 {
 #ifdef _DEBUG
+LOG_FUNC
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Creating observers." ) );
 // create all the observers
 iIdPinObserver = CUsbIdPinObserver::NewL();
 iVBusObserver = CUsbVBusObserver::NewL();
 iOtgStateObserver = CUsbOtgStateObserver::NewL();
-iBusActivityObserver =
+iBusActivityObserver = CUsbBusActivityObserver::NewL();
-CUsbBusActivityObserver::NewL();
+iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL(
-iHostEventNotificationObserver =
+&iUsb);
-CUsbHostEventNotificationObserver::NewL(&iUsb);
+iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL(
-iMessageNotificationObserver =
+&iUsb);
-CUsbMessageNotificationObserver::NewL(&iUsb);
+LOG( "Observers getters" );
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Observers getters." ) );
 if (iIdPinObserver != IdPinObserver())
 {
 User::Leave(KErrGeneral);
 }
 if (iMessageNotificationObserver != MessageNotificationObserver())
 {
 User::Leave(KErrGeneral);
 }
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Observers destructors." ) );
+LOG( "Observers destructors" );
 // idpinobserver is deleted later
 // Vbus observer is deleted later
 delete iOtgStateObserver;
 iOtgStateObserver = 0;
 delete iBusActivityObserver;
 iBusActivityObserver = 0;
 delete iHostEventNotificationObserver;
 iHostEventNotificationObserver = 0;
 delete iMessageNotificationObserver;
 iMessageNotificationObserver = 0;
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Creating states." ) );
+LOG("Creating states");
-User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this)));
+User::LeaveIfError(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL(
-User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this)));
+*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostDelayHandle::NewL(this)));
+User::LeaveIfError(iStates.Append(
+CUsbStateHostDelayNotAttachedHandle::NewL(*this)));
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check State()" ) );
+User::LeaveIfError(iStates.Append(
+CUsbStateHostHandleDropping::NewL(*this)));
+LOG("Check State()" );
 if (iStates[EUsbStateHostAInitiate] != State(EUsbStateHostAInitiate))
 {
 User::Leave(KErrGeneral);
 }
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check CurrentHostState()" ) );
+LOG("Check CurrentHostState()" );
 iHostState = iStates[EUsbStateHostAInitiate];
-		if (iStates[EUsbStateHostAInitiate] != CurrentHostState())
+if (iStates[EUsbStateHostAInitiate] != CurrentHostState())
 {
 User::Leave(KErrGeneral);
 }
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL NotifManager and WarningNotifier." ) );
+LOG("NotifManager and WarningNotifier." );
-CUsbNotifManager* usbnotifmanager = CUsbNotifManager::NewL(this);
+CUsbNotifManager* usbnotifmanager = CUsbNotifManager::NewL(*this);
 RNotifier rnotifier;
 User::LeaveIfError(rnotifier.Connect());
 CUsbWarningNotifier* usbnotifier = CUsbWarningNotifier::NewL(rnotifier,
-usbnotifmanager, EUsbOtgPartiallySupportedDevice);
+*usbnotifmanager, EUsbOtgPartiallySupportedDevice);
 usbnotifier->IsFeedbackNeeded();
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL NotifManager and WarningNotifier destruction." ) );
+LOG( "NotifManager and WarningNotifier destruction." );
 delete usbnotifier;
 rnotifier.Close();
 delete usbnotifmanager;
 // VBus observer is deleted here, due to it is used by usbnotifmanager.usbindicatornotifier
 delete iVBusObserver;
 iVBusObserver = 0;
 // id pin observer is deleted here due to it is used by usbnotifmanager.usbindicatornotifier
 delete iIdPinObserver;
 iIdPinObserver = 0;
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Destructing states." ) );
+LOG("Destructing states");
 iStates.ResetAndDestroy();
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check UsbServiceControl" ) );
+LOG( "Check UsbServiceControl" );
-CUsbServiceControl* usbServiceControl = CUsbServiceControl::NewL(this,
+CUsbServiceControl* usbServiceControl = CUsbServiceControl::NewL(*this,
 iUsb);
 usbServiceControl->RunError(KErrNone);
 delete usbServiceControl;
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL All completed OK." ) );
+LOG("All completed OK" );
 #endif
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SubscribeL(MUsbOtgWatcherStateObserver& aObserver)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SubscribeL" ) );
+LOG_FUNC
 // check if the same observer already exist in a list
-if(KErrNotFound != iOtgStateObservers.Find(&aObserver))
+if (KErrNotFound != iOtgStateObservers.Find(&aObserver))
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SubscribeL Observer already exists." ) );
+LOG( "Observer already exists" );
 Panic(EObserverAlreadyExists);
 return;
 }
 iOtgStateObservers.AppendL(&aObserver);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::UnsubscribeL(MUsbOtgWatcherStateObserver& aObserver)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL" ) );
+LOG_FUNC
-TInt i(iOtgStateObservers.Find(&aObserver));
-if(KErrNotFound == i)
+TInt i(iOtgStateObservers.Find(&aObserver));
-{
+if (KErrNotFound == i)
-FLOG( _L( "[USBOTGWATCHER]\tCUsbIdPinObserver::UnsubscribeL Observer not found." ) );
+{
-Panic(ECanNotFindUsbOtgWatcherStateObserver);
+LOG( "Observer not found" );
-return;
+Panic(ECanNotFindUsbOtgWatcherStateObserver);
-}
+return;
+}
-iOtgStateObservers.Remove(i);
-}
+iOtgStateObservers.Remove(i);
+}

branch	RCL_3
changeset 65	a44cdf4b4bf0
parent 64	8ecef05bbada
child 21	ff9df6630274