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

equal deleted inserted replaced

-:7e15987c4500
+:8c311f9acc5e
 /*
 * 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(CUsbState::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(
+*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[EUsbStateUndefined];
+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);
-iIdPinObserver->SubscribeL(this);
+iVBusObserver->SubscribeL(*this);
+iOtgStateObserver->SubscribeL(*this);
+iBusActivityObserver->SubscribeL(*this);
+iHostEventNotificationObserver->SubscribeL(*this);
+iMessageNotificationObserver->SubscribeL(*this);
+iIdPinObserver->SubscribeL(*this);
 if (CUsbIdPinObserver::EIdPinOn == iIdPinObserver->IdPin())
 {
 StartSessionL();
 }
 //
 // ---------------------------------------------------------------------------
 //
 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)
+{
+TRAP_IGNORE(iIdPinObserver->UnsubscribeL(*this));
+}
+if (iVBusObserver)
+{
+TRAP_IGNORE(iVBusObserver->UnsubscribeL(*this));
+}
+if (iOtgStateObserver)
+{
+TRAP_IGNORE(iOtgStateObserver->UnsubscribeL(*this));
+}
+if (iBusActivityObserver)
+{
+TRAP_IGNORE(iBusActivityObserver->UnsubscribeL(*this));
+}
+if (iHostEventNotificationObserver)
+{
+TRAP_IGNORE(iHostEventNotificationObserver->UnsubscribeL(*this));
+}
+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);
+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);
+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)
+void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf,
-{
+TUsbStateIds aInState)
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HandleProblemL" ) );
+{
-HostHandle()->SetWhat(aWhatKindOf);
+LOG_FUNC
-ChangeHostStateL(EUsbStateHostHandle);
+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
-// for example, USB failed to start
+ChangeHostStateL(EUsbStateHostUndefined);
-if(NULL == iHostState) return;
-iVBusObserver->UnsubscribeL(this);
-iOtgStateObserver->UnsubscribeL(this);
-iBusActivityObserver->UnsubscribeL(this);
-iHostEventNotificationObserver->UnsubscribeL(this);
-iMessageNotificationObserver->UnsubscribeL(this);
-iHostState->JustBeforeLeavingThisStateL();
-iHostState = NULL;
 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);
 }
 // 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);
+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);
 }
 // 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);
+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);
+EUsbStateHostHandleDropping);
 }
 // ---------------------------------------------------------------------------
 // getters
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-CUsbStateHostHandle* CUsbOtgWatcher::HostHandle() const
+CUsbStateHostHandle* CUsbOtgWatcher::HostHandle(TUsbStateIds aInState) const
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HostHandle" ) );
+__ASSERT_DEBUG(iStates[aInState] != NULL, Panic(EBadState));
-__ASSERT_DEBUG(iStates[EUsbStateHostHandle] != NULL, Panic(EBadState));
-return (CUsbStateHostHandle*) iStates[EUsbStateHostHandle];
+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)
-}
+{
+return;
-case KErrNone:
+}
-{
-break; // do normal routine
+case KErrNone:
-}
+{
+break; // do normal routine
-default: // handle the issue
+}
-{
-HandleHostProblemL(EUsbWatcherCanNotStartUsbServices);
+default: // handle the issue
-return;
+{
-}
+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);
+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
-iVBusObserver->SubscribeL(this);
-iOtgStateObserver->SubscribeL(this);
-iBusActivityObserver->SubscribeL(this);
-iHostEventNotificationObserver->SubscribeL(this);
-iMessageNotificationObserver->SubscribeL(this);
 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(CUsbState::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(
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check State()" ) );
+CUsbStateHostDelayNotAttachedHandle::NewL(*this)));
+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)
+void CUsbOtgWatcher::SubscribeL(MUsbOtgWatcherStateObserver& aObserver)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SubscribeL" ) );
+LOG_FUNC
-User::LeaveIfError(iOtgStateObservers.Append(aObserver));
+// check if the same observer already exist in a list
+if (KErrNotFound != iOtgStateObservers.Find(&aObserver))
-}
+{
+LOG( "Observer already exists" );
-// ---------------------------------------------------------------------------
+Panic(EObserverAlreadyExists);
-//
-// ---------------------------------------------------------------------------
-//
-void CUsbOtgWatcher::UnsubscribeL(MUsbOtgWatcherStateObserver* aObserver)
-{
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL" ) );
-if (0 == iOtgStateObservers.Count()) // no items
-{
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL No observers" ) );
 return;
 }
+iOtgStateObservers.AppendL(&aObserver);
-TInt i(0);
-while (i < iOtgStateObservers.Count() && aObserver != iOtgStateObservers[i])
+}
-++i;
+// ---------------------------------------------------------------------------
-if (aObserver == iOtgStateObservers[i]) // found
+//
-{
+// ---------------------------------------------------------------------------
-iOtgStateObservers.Remove(i);
+//
-}
+void CUsbOtgWatcher::UnsubscribeL(MUsbOtgWatcherStateObserver& aObserver)
-else
+{
-{
+LOG_FUNC
-FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL CanNotGetUsbOtgStateWatcherObserver" ) );
+TInt i(iOtgStateObservers.Find(&aObserver));
+if (KErrNotFound == i)
+{
+LOG( "Observer not found" );
 Panic(ECanNotFindUsbOtgWatcherStateObserver);
-}
+return;
 }
+iOtgStateObservers.Remove(i);
+}

changeset 25	8c311f9acc5e
parent 3	47c263f7e521
child 26	0ae0f29418cd