FCL/sf/mw/usbservices: comparison usbengines/usbotgwatcher/src/cusbservicecontrol.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 <usbman.h>
 #include "cusbservicecontrol.h"
 #include "debug.h"
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-CUsbServiceControl::CUsbServiceControl(MUsbServiceControlObserver* aObserver,
+CUsbServiceControl::CUsbServiceControl(MUsbServiceControlObserver& aObserver,
 RUsb& aUsb) :
 CActive(CActive::EPriorityStandard), iObserver(aObserver), iUsb(aUsb),
 iPersonalityId(0)
 {
 CActiveScheduler::Add(this);
 //
 // ---------------------------------------------------------------------------
 //
 CUsbServiceControl::~CUsbServiceControl()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::~CUsbServiceControl" ) );
+LOG_FUNC
 Cancel();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbServiceControl::ConstructL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::ConstructL" ) );
+LOG_FUNC
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 CUsbServiceControl* CUsbServiceControl::NewL(
-MUsbServiceControlObserver* aObserver, RUsb& aUsb)
+MUsbServiceControlObserver& aObserver, RUsb& aUsb)
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::NewL" ) );
+LOG_FUNC
 CUsbServiceControl* self = new (ELeave) CUsbServiceControl(aObserver,
 aUsb);
 CleanupStack::PushL(self);
 self->ConstructL();
 //
 // ---------------------------------------------------------------------------
 //
 TInt CUsbServiceControl::StartL(TInt aPersonalityId)
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::Start aPersonalityId = %d" ), aPersonalityId));
+LOG_FUNC
+LOG1( "aPersonalityId = %d" , aPersonalityId);
 TUsbServiceState serviceState;
 TInt err = iUsb.GetServiceState(serviceState);
 if (KErrNone != err)
 switch (serviceState)
 {
 case EUsbServiceIdle:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start UsbServiceState == EUsbServiceIdle" ) );
+LOG( "UsbServiceState == EUsbServiceIdle" );
 iPersonalityId = aPersonalityId; // when request completed, this will indicate that we started what we wanted
 if (IsActive())
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start Request is outstanding, cancelling first." ) );
+LOG("Request is outstanding, cancelling first" );
 Cancel();
 }
 iUsb.TryStart(aPersonalityId, iStatus);
 SetActive();
 break;
 }
 case EUsbServiceStarted:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start UsbServiceState == EUsbServiceStarted" ) );
+LOG("UsbServiceState == EUsbServiceStarted");
 TInt currentPersonality(0);
 err = iUsb.GetCurrentPersonalityId(currentPersonality);
 if (KErrNone != err)
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::Start Error getting current personality err = %d" ), err));
+LOG1( "Error getting current personality err = %d" , err);
 return err;
 }
 if (aPersonalityId == currentPersonality) // already started
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start Personality already started" ) );
+LOG("Personality already started" );
-iObserver->UsbServiceControlReqCompletedL(KErrInUse);
+iObserver.UsbServiceControlReqCompletedL(KErrInUse);
 return KErrNone;
 }
 // we need to stop current personality and start service with new personailty id
 iPersonalityId = aPersonalityId; // this will indicate that we want to start this personality after
 break;
 }
 case EUsbServiceStarting:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start UsbServiceState == EUsbServiceStarting" ) );
+LOG("UsbServiceState == EUsbServiceStarting" );
 // do exactly the same as in case of EUsbServiceStopping;
 // break statement is not required here
 }
 case EUsbServiceStopping:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start UsbServiceState == EUsbServiceStopping" ) );
+LOG( "UsbServiceState == EUsbServiceStopping" );
 // subscribe for usb service state change, and start new usb service once current one started/stopped
 iPersonalityId = aPersonalityId; // this will indicate that we want to start this personality
 // this check is needed due to usb service might be stopping by other client
 if (IsActive())
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start Request outstanding. Waiting for completion." ) );
+LOG( "Request outstanding. Waiting for completion" );
 return KErrNone; // when the outstanding request get completed, we start usb services with iPersonalityId
 }
 // otherwise, monitor usb service state
 iUsb.ServiceStateNotification(iServiceState, iStatus);
 break;
 }
 case EUsbServiceFatalError:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start UsbServiceState == EUsbServiceFatalError" ) );
+LOG( "UsbServiceState == EUsbServiceFatalError" );
 return KErrGeneral;
 }
 default:
 {
-Panic(EUnknownUsbServiceState);
+Panic( EUnknownUsbServiceState);
 }
 }
 return KErrNone;
 //
 // ---------------------------------------------------------------------------
 //
 TInt CUsbServiceControl::StopL()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Stop" ) );
+LOG_FUNC
 TUsbServiceState serviceState;
 TInt err = iUsb.GetServiceState(serviceState);
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::StopL = %d; Usb service state = %d" ), err, serviceState));
+LOG2("err = %d; serviceState = %d" , err, serviceState);
 if (KErrNone != err)
 {
 return err;
 }
 switch (serviceState)
 {
 case EUsbServiceIdle:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Stop UsbServiceState == EUsbServiceIdle" ) );
+LOG("UsbServiceState == EUsbServiceIdle" );
 return KErrNone;
 }
 case EUsbServiceStarted:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Stop UsbServiceState == EUsbServiceStarted" ) );
+LOG("UsbServiceState == EUsbServiceStarted" );
 if (IsActive())
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Stop Request is outstanding, cancelling it." ) );
+LOG("Request is outstanding, cancelling it" );
 Cancel();
 }
 iUsb.TryStop(iStatus);
 SetActive();
 break;
 }
 case EUsbServiceStopping:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Stop UsbServiceState == EUsbServiceStopping" ) );
+LOG( "UsbServiceState == EUsbServiceStopping" );
 // do exactly the same as in case of EUsbServiceStarting;
 // break statement is not required here
 }
 case EUsbServiceStarting:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Stop UsbServiceState == EUsbServiceStarting" ) );
+LOG("UsbServiceState == EUsbServiceStarting" );
 // subscribe for usb service state change, and stop usb service once current one started
 iPersonalityId = 0; // this will indicate that we do not want to start this personality
 // this check is needed due to usb service might be starting by other client
 if (IsActive())
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Stop Request is outstanding, waiting for completion. " ) );
+LOG("Request is outstanding, waiting for completion" );
 return KErrNone; // when this request get completed, we request to stop usb services
 }
 // otherwise, monitor usb service state
 iUsb.ServiceStateNotification(iServiceState, iStatus);
 break;
 }
 case EUsbServiceFatalError:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start UsbServiceState == EUsbServiceFatalError" ) );
+LOG("UsbServiceState == EUsbServiceFatalError" );
 return KErrGeneral;
 }
 default:
 {
-Panic(EUnknownUsbServiceState);
+Panic( EUnknownUsbServiceState);
 }
 }
 return KErrNone;
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbServiceControl::RunL()
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::RunL iStatus %d" ), iStatus.Int()));
+LOG_FUNC
+LOG1("iStatus = %d" , iStatus.Int());
 if (KErrNone != iStatus.Int())
 {
-iObserver->UsbServiceControlReqCompletedL(iStatus.Int());
+iObserver.UsbServiceControlReqCompletedL(iStatus.Int());
 return;
 }
 TUsbServiceState serviceState;
 TInt err = iUsb.GetServiceState(serviceState);
 if (KErrNone != err)
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::RunL error while getting service state %d" ), err));
+LOG1("Error while getting service state %d" , err);
-iObserver->UsbServiceControlReqCompletedL(err);
+iObserver.UsbServiceControlReqCompletedL(err);
 return;
 }
 switch (serviceState)
 {
 case EUsbServiceIdle: // usb service stopped
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::RunL UsbServiceState == EUsbServiceIdle" ) );
+LOG("UsbServiceState == EUsbServiceIdle" );
 if (iPersonalityId != 0) // during service stopping, requested to start it
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::RunL Requested to start personality %d. Starting it." ), iPersonalityId));
+LOG1("Requested to start personality %d. Starting it." , iPersonalityId);
 TInt personalityId = iPersonalityId;
 iPersonalityId = 0; // reset
 err = StartL(personalityId);
-if(KErrNone != err)
+if (KErrNone != err)
 {
-iObserver->UsbServiceControlReqCompletedL(err);
+iObserver.UsbServiceControlReqCompletedL(err);
 }
 return;
 }
 // otherwise, we've done, notify
-iObserver->UsbServiceControlReqCompletedL(KErrNone);
+iObserver.UsbServiceControlReqCompletedL(KErrNone);
 break;
 }
 case EUsbServiceStarted:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start UsbServiceState == EUsbServiceStarted" ) );
+LOG("UsbServiceState == EUsbServiceStarted" );
 TInt currentPersonality(0);
 err = iUsb.GetCurrentPersonalityId(currentPersonality);
 if (KErrNone != err)
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::RunL error while getting PersonalityId err = %d" ), err));
+LOG1("Error while getting PersonalityId err = %d" , err);
-iObserver->UsbServiceControlReqCompletedL(err);
+iObserver.UsbServiceControlReqCompletedL(err);
 return;
 }
 if (iPersonalityId == currentPersonality) // already done
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start Personality already started." ) );
+LOG("Personality already started" );
 iPersonalityId = 0;
-iObserver->UsbServiceControlReqCompletedL(KErrNone);
+iObserver.UsbServiceControlReqCompletedL(KErrNone);
 return;
 }
 if (iPersonalityId == 0) // during service start requested to stop it
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start Requested to stop personality. Stopping." ) );
+LOG("Requested to stop personality. Stopping." );
 err = StopL();
-if(KErrNone != err)
+if (KErrNone != err)
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::RunL error while stopping personality err = %d" ), err));
+LOG1("Error while stopping personality err = %d" , err);
-iObserver->UsbServiceControlReqCompletedL(err);
+iObserver.UsbServiceControlReqCompletedL(err);
 }
 return;
 }
 // otherwise, during service start, requested to start it with another personality
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::RunL Requested to start personality %d. Starting it." ), iPersonalityId));
+LOG1( "Requested to start personality %d. Starting it.", iPersonalityId);
 TInt personalityId = iPersonalityId;
 iPersonalityId = 0; // reset
 err = StartL(personalityId);
-if(KErrNone != err)
+if (KErrNone != err)
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::RunL error while starting personality err = %d" ), err));
+LOG1("Error while starting personality err = %d" , err);
-iObserver->UsbServiceControlReqCompletedL(err);
+iObserver.UsbServiceControlReqCompletedL(err);
 }
 break;
 }
 case EUsbServiceStarting:
 {
 // do exactly same as in EUsbServiceStopping
 // break statement is not required here
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start State == EUsbServiceStarting. Continue." ) );
+LOG("State == EUsbServiceStarting. Continue." );
 }
 case EUsbServiceStopping:
 {
 // we are not interested in these states, just continue monitoring
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start State == EUsbServiceStopping. Continue." ) );
+LOG("State == EUsbServiceStopping. Continue." );
 iUsb.ServiceStateNotification(iServiceState, iStatus);
 SetActive();
 break;
 }
 case EUsbServiceFatalError:
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::Start UsbServiceState == EUsbServiceFatalError" ) );
+LOG("UsbServiceState == EUsbServiceFatalError" );
-iObserver->UsbServiceControlReqCompletedL(KErrGeneral);
+iObserver.UsbServiceControlReqCompletedL(KErrGeneral);
 break;
 }
 default:
 {
-Panic(EUnknownUsbServiceState);
+Panic( EUnknownUsbServiceState);
 }
 }
 }
 //
 // ---------------------------------------------------------------------------
 //
 TInt CUsbServiceControl::RunError(TInt aError)
 {
-FTRACE(FPrint(_L( "[USBOTGWATCHER]\tCUsbServiceControl::RunError aError %d" ), aError ));
+LOG_FUNC
-TRAP_IGNORE(iObserver->UsbServiceControlReqCompletedL(aError));
+LOG1("aError = %d", aError );
+TRAP_IGNORE(iObserver.UsbServiceControlReqCompletedL(aError));
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CUsbServiceControl::DoCancel()
 {
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::DoCancel Cancelling interest to Usb TryStart."))
+LOG( "Cancelling interest to Usb TryStart.")
 iUsb.CancelInterest(RUsb::ETryStart);
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::DoCancel Cancelling interest to Usb TrySop."))
+LOG( "Cancelling interest to Usb TrySop.")
 iUsb.CancelInterest(RUsb::ETryStop);
-FLOG( _L( "[USBOTGWATCHER]\tCUsbServiceControl::DoCancel Cancelling interest to usb states notifications."))
+LOG("Cancelling interest to usb states notifications.")
 iUsb.ServiceStateNotificationCancel();
 }

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