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

equal deleted inserted replaced

-:a15c582fbf97
+:ff9df6630274
 /*
-* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2008 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".
 #ifdef _DEBUG
 SelfTestL();
 #endif
 #ifndef STIF
-User::LeaveIfError(RProperty::Define(KPSUidUsbWatcher,
+LEAVEIFERROR(RProperty::Define(KPSUidUsbWatcher,
 KUsbWatcherIsPeripheralConnected, RProperty::EInt,
 KAlwaysPassPolicy, KLocalServicesPolicy));
-User::LeaveIfError(RProperty::Set(KPSUidUsbWatcher,
+LEAVEIFERROR(RProperty::Set(KPSUidUsbWatcher,
 KUsbWatcherIsPeripheralConnected,
 KUsbWatcherPeripheralIsNotConnected));
 #endif
 iUsbServiceControl = CUsbServiceControl::NewL(*this, iUsb);
-User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(*this)));
+LEAVEIFERROR(iStates.Append(CUsbStateHostUndefined::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(*this)));
+LEAVEIFERROR(iStates.Append(CUsbStateHostAInitiate::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(*this)));
+LEAVEIFERROR(iStates.Append(CUsbStateHostAHost::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(*this)));
+LEAVEIFERROR(iStates.Append(CUsbStateHostAPeripheral::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL(
+LEAVEIFERROR(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL(
 *this)));
-User::LeaveIfError(iStates.Append(
+LEAVEIFERROR(iStates.Append(
 CUsbStateHostDelayNotAttachedHandle::NewL(*this)));
-User::LeaveIfError(iStates.Append(
+LEAVEIFERROR(iStates.Append(
 CUsbStateHostHandleDropping::NewL(*this)));
 iIdPinObserver = CUsbIdPinObserver::NewL();
 iVBusObserver = CUsbVBusObserver::NewL();
 iOtgStateObserver = CUsbOtgStateObserver::NewL();
 iBusActivityObserver = CUsbBusActivityObserver::NewL();
 //
 // ---------------------------------------------------------------------------
 //
 EXPORT_C TBool CUsbOtgWatcher::IsDeviceA()
 {
-__ASSERT_DEBUG(iIdPinObserver != NULL, Panic(EIdPinObserverNULLPointer));
+ASSERT_PANIC(iIdPinObserver != NULL, EIdPinObserverNULLPointer);
 return (iIdPinObserver->IdPin() == CUsbIdPinObserver::EIdPinOn
 ? ETrue
 : EFalse);
 }
 LOG1( "iUsbServiceControl->Stop() err = %d", err );
 if (KErrNone != err)
 {
 LOG( "ErrorStoppingUsbServices" );
-Panic(ECanNotStopUsbServices);
+PANIC(ECanNotStopUsbServices);
 }
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::IdPinErrorL(TInt aError)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 HandleHostProblemL(EUsbWatcherIdPinError, EUsbStateHostHandleDropping);
 }
 // From VBus observer
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::VBusDownL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->VBusDownL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::VBusUpL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->VBusUpL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::VBusObserverErrorL(TInt aError)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 HandleHostProblemL(EUsbWatcherVBusObserverError,
 EUsbStateHostHandleDropping);
 }
 // From OTG state observer
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::AIdleL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->AIdleL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::AHostL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->AHostL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::APeripheralL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->APeripheralL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::AVBusErrorL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->AVBusErrorL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BIdleL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->BIdleL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BPeripheralL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->BPeripheralL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BHostL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->BHostL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::OtgStateErrorL(TInt aError)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 HandleHostProblemL(EUsbWatcherOtgStateError, EUsbStateHostHandleDropping);
 }
 // From bus activity observer
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BusIdleL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->BusIdleL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BusActiveL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->BusActiveL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BusActivityErrorL(TInt aError)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 // no action, continue
 }
 // From Host Event notification observer
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DeviceAttachedL(TDeviceEventInformation aTdi)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->DeviceAttachedL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DeviceDetachedL(TDeviceEventInformation aTdi)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->DeviceDetachedL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DriverLoadSuccessL(TDeviceEventInformation aTdi)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->DriverLoadSuccessL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DriverLoadPartialSuccessL(TDeviceEventInformation aTdi)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->DriverLoadPartialSuccessL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::DriverLoadFailureL(TDeviceEventInformation aTdi)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->DriverLoadFailureL(aTdi);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::HostEventNotificationErrorL(TInt aError)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 HandleHostProblemL(EUsbWatcherHostEventNotificationError,
 EUsbStateHostHandleDropping);
 }
 // From message notification observer
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::MessageNotificationReceivedL(TInt aMessage)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->MessageNotificationReceivedL(aMessage);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::BadHubPositionL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->BadHubPositionL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::VBusErrorL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->VBusErrorL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SrpReceivedL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->SrpReceivedL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::SessionRequestedL()
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 iHostState->SessionRequestedL();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbOtgWatcher::MessageNotificationErrorL(TInt aError)
 {
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));
+ASSERT_PANIC(iHostState != NULL, EBadHostState);
 HandleHostProblemL(EUsbWatcherMessageNotificationError,
 EUsbStateHostHandleDropping);
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 CUsbStateHostHandle* CUsbOtgWatcher::HostHandle(TUsbStateIds aInState) const
 {
-__ASSERT_DEBUG(iStates[aInState] != NULL, Panic(EBadState));
+ASSERT_PANIC(iStates[aInState] != NULL, EBadState);
 return (CUsbStateHostHandle*) iStates[aInState];
 }
 // ---------------------------------------------------------------------------
 }
 // sets new state
 // be careful to add states into States in exactly the same order as they enumerated
-// this method will work right as long as states, which in the enumeration, is added to the list iStates in the same order as they enumerated
+// this method will work right as long as states, which in the enumeration, is added
-// and no one state is added, if all previous states are not added. no need to add all states, but if added - previous all must be added.
+// to the list iStates in the same order as they enumerated and no one state is added,
+// if all previous states are not added. no need to add all states, but if added -
+// previous all must be added.
 // For the general case, when some states added, some not, this method has to implement search by state ID. for this CUsbOtgWatcher::Id() is maintained.
 iState = iStates[aNewStateId];
-__ASSERT_DEBUG(iState != NULL, Panic(EBadState));
+ASSERT_PANIC(iState != NULL, EBadState);
 iState->JustAdvancedToThisStateL(); // do any initial activity, once advanced to the state
 }
 }
 // set new state
 // be careful to add states into States in exactly the same order as they enumerated
-// this method will work right as long as states, which in the enumeration, is added to the list iStates in the same order as they enumerated
+// this method will work right as long as states, which in the enumeration, is added
-// and no one state is added, if all previous states are not added. no need to add all states, but if added - previous all must be added.
+// to the list iStates in the same order as they enumerated and no one state is added,
-// For the general case, when some states added, some not, this method has to implement search by state Id. for this CUsbOtgWatcher::Id() is maintained.
+// if all previous states are not added. no need to add all states, but if added -
+// previous all must be added.
+// For the general case, when some states added, some not, this method has to implement search by state ID. for this CUsbOtgWatcher::Id() is maintained.
 iHostState = iStates[aNewStateId];
-__ASSERT_DEBUG(iHostState != NULL, Panic(EBadState));
+ASSERT_PANIC(iHostState != NULL, 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)
 {
 LOG_FUNC
 LOG1( "aError = %d" , aError);
+iUsbServiceRequest = CUsbServiceControl::ERequestUndefined;
 switch (aError)
 {
 case KErrInUse:
 // usb services already started (this might happen if more than one idpin on event come)
 {
 case KErrNone:
 {
 break; // do normal routine
 }
+case KErrNoMemory:
-default: // handle the issue
+{
+HandleHostProblemL(EUsbWatcherNoMemory,
+EUsbStateHostHandleDropping);
+return;
+}
+default:
+// handle the issue
 {
 if (iUsbServiceRequest == CUsbServiceControl::EStartUsbService) // Handle only start issues
 {
-HandleHostProblemL(EUsbWatcherCanNotStartUsbServices,
+HandleHostProblemL(EUsbWatcherNoMemory,
 EUsbStateHostHandleDropping);
 }
 iUsbServiceRequest = CUsbServiceControl::ERequestUndefined;
 return;
 }
 switch (serviceState)
 {
 case EUsbServiceIdle: // just stopped usb service
 {
 LOG("UsbServiceState == EUsbServiceIdle" );
 // do nothing
 break;
 }
 case EUsbServiceStarted: // just started usb service
 {
 LOG( "UsbServiceState == EUsbServiceStarted" );
 ChangeHostStateL(EUsbStateHostAInitiate);
 case 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
+PANIC(EUnexpectedUsbServiceState);
+break;
 }
 case 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
+PANIC(EUnexpectedUsbServiceState);
+break;
 }
 case EUsbServiceFatalError:
 {
 LOG( "UsbServiceState == EUsbServiceFatalError" );
-Panic(EUnexpectedUsbServiceState);
+PANIC(EUnexpectedUsbServiceState);
 break;
 }
 default:
 {
-Panic(EUnknownUsbServiceState);
+PANIC(EUnknownUsbServiceState);
 }
 }
 }
 // ---------------------------------------------------------------------------
 LOG( "Observers getters" );
 if (iIdPinObserver != IdPinObserver())
 {
-User::Leave(KErrGeneral);
+LEAVE(KErrGeneral);
 }
 if (iOtgStateObserver != OtgStateObserver())
 {
-User::Leave(KErrGeneral);
+LEAVE(KErrGeneral);
 }
 if (iBusActivityObserver != BusActivityObserver())
 {
-User::Leave(KErrGeneral);
+LEAVE(KErrGeneral);
 }
 if (iHostEventNotificationObserver != HostEventNotificationObserver())
 {
-User::Leave(KErrGeneral);
+LEAVE(KErrGeneral);
 }
 if (iMessageNotificationObserver != MessageNotificationObserver())
 {
-User::Leave(KErrGeneral);
+LEAVE(KErrGeneral);
 }
 LOG( "Observers destructors" );
 // idpinobserver is deleted later
 delete iMessageNotificationObserver;
 iMessageNotificationObserver = 0;
 LOG("Creating states");
-User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(*this)));
+LEAVEIFERROR(iStates.Append(CUsbStateHostUndefined::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(*this)));
+LEAVEIFERROR(iStates.Append(CUsbStateHostAInitiate::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(*this)));
+LEAVEIFERROR(iStates.Append(CUsbStateHostAHost::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(*this)));
+LEAVEIFERROR(iStates.Append(CUsbStateHostAPeripheral::NewL(*this)));
-User::LeaveIfError(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL(
+LEAVEIFERROR(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL(
 *this)));
-User::LeaveIfError(iStates.Append(
+LEAVEIFERROR(iStates.Append(
 CUsbStateHostDelayNotAttachedHandle::NewL(*this)));
-User::LeaveIfError(iStates.Append(
+LEAVEIFERROR(iStates.Append(
 CUsbStateHostHandleDropping::NewL(*this)));
 LOG("Check State()" );
 if (iStates[EUsbStateHostAInitiate] != State(EUsbStateHostAInitiate))
 {
-User::Leave(KErrGeneral);
+LEAVE(KErrGeneral);
 }
 LOG("Check CurrentHostState()" );
 iHostState = iStates[EUsbStateHostAInitiate];
 if (iStates[EUsbStateHostAInitiate] != CurrentHostState())
 {
-User::Leave(KErrGeneral);
+LEAVE(KErrGeneral);
 }
 LOG("NotifManager and WarningNotifier." );
 CUsbNotifManager* usbnotifmanager = CUsbNotifManager::NewL(*this);
 RNotifier rnotifier;
-User::LeaveIfError(rnotifier.Connect());
+LEAVEIFERROR(rnotifier.Connect());
 CUsbWarningNotifier* usbnotifier = CUsbWarningNotifier::NewL(rnotifier,
 *usbnotifmanager, EUsbOtgPartiallySupportedDevice);
 usbnotifier->IsFeedbackNeeded();
 LOG( "NotifManager and WarningNotifier destruction." );
 // check if the same observer already exist in a list
 if (KErrNotFound != iOtgStateObservers.Find(&aObserver))
 {
 LOG( "Observer already exists" );
-Panic(EObserverAlreadyExists);
+PANIC(EObserverAlreadyExists);
 return;
 }
 iOtgStateObservers.AppendL(&aObserver);
 }
 TInt i(iOtgStateObservers.Find(&aObserver));
 if (KErrNotFound == i)
 {
 LOG( "Observer not found" );
-Panic(ECanNotFindUsbOtgWatcherStateObserver);
+PANIC(ECanNotFindUsbOtgWatcherStateObserver);
 return;
 }
 iOtgStateObservers.Remove(i);
 }

branch	RCL_3
changeset 21	ff9df6630274
parent 20	a15c582fbf97
child 74	830546d5951a
child 79	25fce757be94