1 /* |
1 /* |
2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
3 * All rights reserved. |
3 * All rights reserved. |
4 * This component and the accompanying materials are made available |
4 * This component and the accompanying materials are made available |
5 * under the terms of "Eclipse Public License v1.0" |
5 * under the terms of "Eclipse Public License v1.0" |
6 * which accompanies this distribution, and is available |
6 * which accompanies this distribution, and is available |
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Implementation |
|
15 * |
8 * |
16 */ |
9 * Initial Contributors: |
17 |
10 * Nokia Corporation - initial contribution. |
18 |
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Implementation |
|
15 * |
|
16 */ |
19 #include <usbpersonalityids.h> |
17 #include <usbpersonalityids.h> |
20 #include <usbuinotif.h> |
18 #include <usbuinotif.h> |
21 #include <UsbWatcherInternalPSKeys.h> |
19 #include <UsbWatcherInternalPSKeys.h> |
22 |
|
23 #include "cusbotgwatcher.h" |
20 #include "cusbotgwatcher.h" |
24 #include "cusbstate.h" |
21 #include "cusbstate.h" |
25 |
|
26 #include "cusbstatehostainitiate.h" |
22 #include "cusbstatehostainitiate.h" |
27 #include "cusbstatehostahost.h" |
23 #include "cusbstatehostahost.h" |
28 #include "cusbstatehostaperipheral.h" |
24 #include "cusbstatehostaperipheral.h" |
29 #include "cusbstatehostaidle.h" |
|
30 #include "cusbstatehosthandle.h" |
25 #include "cusbstatehosthandle.h" |
31 #include "cusbstatehostdelayhandle.h" |
26 #include "cusbstatehostdelayhandle.h" |
|
27 #include "cusbstatehostdelayattachedhandle.h" |
|
28 #include "cusbstatehostdelaynotattachedhandle.h" |
|
29 #include "cusbstatehosthandledropping.h" |
32 #include "cusbstatehostundefined.h" |
30 #include "cusbstatehostundefined.h" |
33 |
|
34 #include "cusbwarningnotifier.h" |
31 #include "cusbwarningnotifier.h" |
35 |
|
36 #ifndef STIF |
32 #ifndef STIF |
37 #include "cusbnotifmanager.h" |
33 #include "cusbnotifmanager.h" |
38 #else |
34 #else |
39 #include "mockcusbnotifmanager.h" |
35 #include "mockcusbnotifmanager.h" |
40 #endif |
36 #endif |
41 |
|
42 #include "errors.h" |
37 #include "errors.h" |
43 #include "debug.h" |
38 #include "debug.h" |
44 #include "panic.h" |
39 #include "panic.h" |
45 |
|
46 _LIT_SECURITY_POLICY_PASS( KAlwaysPassPolicy ); |
40 _LIT_SECURITY_POLICY_PASS( KAlwaysPassPolicy ); |
47 _LIT_SECURITY_POLICY_C1( KLocalServicesPolicy, ECapabilityLocalServices ); |
41 _LIT_SECURITY_POLICY_C1( KLocalServicesPolicy, ECapabilityLocalServices ); |
48 |
42 |
49 // --------------------------------------------------------------------------- |
43 // --------------------------------------------------------------------------- |
50 // |
44 // |
51 // --------------------------------------------------------------------------- |
45 // --------------------------------------------------------------------------- |
52 // |
46 // |
53 CUsbOtgWatcher::CUsbOtgWatcher(RUsb& aUsbMan) : |
47 CUsbOtgWatcher::CUsbOtgWatcher(RUsb& aUsbMan) : |
54 iUsb(aUsbMan), iPersonalityId(KUsbPersonalityIdMTP) |
48 iUsb(aUsbMan), iPersonalityId(KUsbPersonalityIdMTP), iUsbServiceRequest( |
55 { |
49 CUsbServiceControl::ERequestUndefined) |
56 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::CUsbOtgWatcher" ) ); |
50 { |
|
51 LOG_FUNC |
57 } |
52 } |
58 |
53 |
59 // --------------------------------------------------------------------------- |
54 // --------------------------------------------------------------------------- |
60 // |
55 // |
61 // --------------------------------------------------------------------------- |
56 // --------------------------------------------------------------------------- |
62 // |
57 // |
63 void CUsbOtgWatcher::ConstructL() |
58 void CUsbOtgWatcher::ConstructL() |
64 { |
59 { |
65 |
60 LOG_FUNC |
66 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::ConstructL" ) ); |
|
67 |
61 |
68 #ifdef _DEBUG |
62 #ifdef _DEBUG |
69 SelfTestL(); |
63 SelfTestL(); |
70 #endif |
64 #endif |
71 |
65 |
72 #ifndef STIF |
66 #ifndef STIF |
73 User::LeaveIfError(RProperty::Define( KPSUidUsbWatcher, |
67 User::LeaveIfError(RProperty::Define(KPSUidUsbWatcher, |
74 KUsbWatcherIsPeripheralConnected, RProperty::EInt, KAlwaysPassPolicy, |
68 KUsbWatcherIsPeripheralConnected, RProperty::EInt, |
75 KLocalServicesPolicy ) ); |
69 KAlwaysPassPolicy, KLocalServicesPolicy)); |
76 |
70 |
77 User::LeaveIfError( RProperty::Set( KPSUidUsbWatcher, |
71 User::LeaveIfError(RProperty::Set(KPSUidUsbWatcher, |
78 KUsbWatcherIsPeripheralConnected, |
72 KUsbWatcherIsPeripheralConnected, |
79 KUsbWatcherPeripheralIsNotConnected ) ); |
73 KUsbWatcherPeripheralIsNotConnected)); |
80 #endif |
74 #endif |
81 |
75 |
82 iUsbServiceControl = CUsbServiceControl::NewL(this, iUsb); |
76 iUsbServiceControl = CUsbServiceControl::NewL(*this, iUsb); |
83 |
77 |
84 User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(this))); |
78 User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(*this))); |
85 User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this))); |
79 User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(*this))); |
86 User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this))); |
80 User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(*this))); |
87 User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this))); |
81 User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(*this))); |
88 User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this))); |
82 |
89 User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this))); |
83 User::LeaveIfError(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL( |
90 User::LeaveIfError(iStates.Append(CUsbStateHostDelayHandle::NewL(this))); |
84 *this))); |
|
85 User::LeaveIfError(iStates.Append( |
|
86 CUsbStateHostDelayNotAttachedHandle::NewL(*this))); |
|
87 User::LeaveIfError(iStates.Append( |
|
88 CUsbStateHostHandleDropping::NewL(*this))); |
91 |
89 |
92 iIdPinObserver = CUsbIdPinObserver::NewL(); |
90 iIdPinObserver = CUsbIdPinObserver::NewL(); |
93 iVBusObserver = CUsbVBusObserver::NewL(); |
91 iVBusObserver = CUsbVBusObserver::NewL(); |
94 iOtgStateObserver = CUsbOtgStateObserver::NewL(); |
92 iOtgStateObserver = CUsbOtgStateObserver::NewL(); |
95 iBusActivityObserver = CUsbBusActivityObserver::NewL(); |
93 iBusActivityObserver = CUsbBusActivityObserver::NewL(); |
96 iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL( |
94 iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL( |
97 &iUsb); |
95 &iUsb); |
98 iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL( |
96 iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL( |
99 &iUsb); |
97 &iUsb); |
100 |
98 |
101 iHostState = iStates[EUsbStateHostUndefined]; |
99 iHostState = iStates[EUsbStateHostUndefined]; |
102 |
100 |
103 // Notif manager must be created at least after VBus observer and iHostState initialization |
101 // Notif manager must be created at least after VBus observer and iHostState initialization |
104 // to allow USb indicator subscribe to its notifications at construction and check their's current states |
102 // to allow USb indicator subscribe to its notifications at construction and check their's current states |
105 iNotifManager = CUsbNotifManager::NewL(this); |
103 iNotifManager = CUsbNotifManager::NewL(*this); |
106 |
104 |
107 iVBusObserver->SubscribeL(*this); |
105 iVBusObserver->SubscribeL(*this); |
108 iOtgStateObserver->SubscribeL(*this); |
106 iOtgStateObserver->SubscribeL(*this); |
109 iBusActivityObserver->SubscribeL(*this); |
107 iBusActivityObserver->SubscribeL(*this); |
110 iHostEventNotificationObserver->SubscribeL(*this); |
108 iHostEventNotificationObserver->SubscribeL(*this); |
254 // |
253 // |
255 // --------------------------------------------------------------------------- |
254 // --------------------------------------------------------------------------- |
256 // |
255 // |
257 void CUsbOtgWatcher::SetPreviousPersonalityL() |
256 void CUsbOtgWatcher::SetPreviousPersonalityL() |
258 { |
257 { |
259 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPreviousPersonalityL" ) ); |
258 LOG_FUNC |
260 |
259 |
261 iState->SetPreviousPersonalityL(); |
260 iState->SetPreviousPersonalityL(); |
262 } |
261 } |
263 |
262 |
264 // --------------------------------------------------------------------------- |
263 // --------------------------------------------------------------------------- |
265 // |
264 // |
266 // --------------------------------------------------------------------------- |
265 // --------------------------------------------------------------------------- |
267 // |
266 // |
268 void CUsbOtgWatcher::CancelSetPreviousPersonalityL() |
267 void CUsbOtgWatcher::CancelSetPreviousPersonalityL() |
269 { |
268 { |
270 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::CancelSetPreviousPersonalityL" ) ); |
269 LOG_FUNC |
271 |
270 |
272 iState->CancelSetPreviousPersonalityL(); |
271 iState->CancelSetPreviousPersonalityL(); |
273 } |
272 } |
274 |
273 |
275 // --------------------------------------------------------------------------- |
274 // --------------------------------------------------------------------------- |
276 // |
275 // |
277 // --------------------------------------------------------------------------- |
276 // --------------------------------------------------------------------------- |
278 // |
277 // |
279 void CUsbOtgWatcher::SetPreviousPreviousPersonalityOnDisconnectL() |
278 void CUsbOtgWatcher::SetPreviousPreviousPersonalityOnDisconnectL() |
280 { |
279 { |
281 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPreviousPreviousPersonalityOnDisconnectL" ) ); |
280 LOG_FUNC |
282 |
281 |
283 } |
282 } |
284 |
283 |
285 // From IdPin observer |
284 // From IdPin observer |
286 // --------------------------------------------------------------------------- |
285 // --------------------------------------------------------------------------- |
287 // |
286 // |
288 // --------------------------------------------------------------------------- |
287 // --------------------------------------------------------------------------- |
289 // |
288 // |
290 void CUsbOtgWatcher::StartSessionL() |
289 void CUsbOtgWatcher::StartSessionL() |
291 { |
290 { |
292 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL" ) ); |
291 LOG_FUNC |
293 |
292 |
294 if (!CanStartSessionL()) |
293 if (!CanStartSessionL()) |
295 { |
294 { |
296 HandleHostProblemL(EUsbWatcherErrorInConnection, EUsbStateHostHandle); |
295 HandleHostProblemL(EUsbWatcherCanNotStartSession, |
|
296 EUsbStateHostHandleDropping); |
297 return; |
297 return; |
298 } |
298 } |
299 |
299 |
|
300 iUsbServiceRequest = CUsbServiceControl::EStartUsbService; |
300 TInt err = iUsbServiceControl->StartL(iPersonalityId); |
301 TInt err = iUsbServiceControl->StartL(iPersonalityId); |
301 if (KErrNone != err) |
302 if (KErrNone != err) |
302 { |
303 { |
303 FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL Can not start usb services. reason = %d" ), err)); |
304 LOG1( "Can not start usb services. err = %d" , err); |
304 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle); |
305 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, |
|
306 EUsbStateHostHandleDropping); |
305 return; |
307 return; |
306 } |
308 } |
307 |
309 |
308 // call back from iUsbServiceControl->Start(iPersonalityId) call is UsbServiceControlReqCompletedL(TInt aError) |
310 // call back from iUsbServiceControl->Start(iPersonalityId) call is UsbServiceControlReqCompletedL(TInt aError) |
309 // so, continue there if everything is OK |
311 // so, continue there if everything is OK |
312 |
314 |
313 // --------------------------------------------------------------------------- |
315 // --------------------------------------------------------------------------- |
314 // |
316 // |
315 // --------------------------------------------------------------------------- |
317 // --------------------------------------------------------------------------- |
316 // |
318 // |
317 void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf, TUsbStateIds aInState ) |
319 void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf, |
318 { |
320 TUsbStateIds aInState) |
319 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HandleProblemL" ) ); |
321 { |
|
322 LOG_FUNC |
320 HostHandle(aInState)->SetWhat(aWhatKindOf); |
323 HostHandle(aInState)->SetWhat(aWhatKindOf); |
321 ChangeHostStateL(aInState); |
324 ChangeHostStateL(aInState); |
322 } |
325 } |
323 |
326 |
324 // --------------------------------------------------------------------------- |
327 // --------------------------------------------------------------------------- |
325 // |
328 // |
326 // --------------------------------------------------------------------------- |
329 // --------------------------------------------------------------------------- |
327 // |
330 // |
328 void CUsbOtgWatcher::IdPinOnL() |
331 void CUsbOtgWatcher::IdPinOnL() |
329 { |
332 { |
330 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOnL" ) ); |
333 LOG_FUNC |
331 StartSessionL(); |
334 StartSessionL(); |
332 } |
335 } |
333 |
336 |
334 // --------------------------------------------------------------------------- |
337 // --------------------------------------------------------------------------- |
335 // |
338 // |
336 // --------------------------------------------------------------------------- |
339 // --------------------------------------------------------------------------- |
337 // |
340 // |
338 void CUsbOtgWatcher::IdPinOffL() |
341 void CUsbOtgWatcher::IdPinOffL() |
339 { |
342 { |
340 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL" ) ); |
343 LOG_FUNC |
341 |
344 |
342 ChangeHostStateL(EUsbStateHostUndefined); |
345 ChangeHostStateL(EUsbStateHostUndefined); |
343 |
346 |
344 iNotifManager->CloseAllNotifiers(); |
347 iNotifManager->CloseAllNotifiers(); |
345 |
348 |
346 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL Before DisableFunctionDriverLoad " ) ); |
|
347 Usb().DisableFunctionDriverLoading(); |
349 Usb().DisableFunctionDriverLoading(); |
348 |
350 |
349 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL Before TryStop" ) ); |
351 iUsbServiceRequest = CUsbServiceControl::EStopUsbService; |
350 |
|
351 TInt err = iUsbServiceControl->StopL(); |
352 TInt err = iUsbServiceControl->StopL(); |
352 |
353 |
|
354 LOG1( "iUsbServiceControl->Stop() err = %d", err ); |
|
355 |
353 if (KErrNone != err) |
356 if (KErrNone != err) |
354 { |
357 { |
355 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOnL ErrorStoppingUsbServices" ) ); |
358 LOG( "ErrorStoppingUsbServices" ); |
356 Panic(ECanNotStopUsbServices); |
359 Panic(ECanNotStopUsbServices); |
357 } |
360 } |
358 |
|
359 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL iUsbServiceControl->Stop() OK" ) ); |
|
360 } |
361 } |
361 |
362 |
362 // --------------------------------------------------------------------------- |
363 // --------------------------------------------------------------------------- |
363 // |
364 // |
364 // --------------------------------------------------------------------------- |
365 // --------------------------------------------------------------------------- |
365 // |
366 // |
366 void CUsbOtgWatcher::IdPinErrorL(TInt aError) |
367 void CUsbOtgWatcher::IdPinErrorL(TInt aError) |
367 { |
368 { |
368 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinErrorL" ) ); |
369 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
369 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
370 HandleHostProblemL(EUsbWatcherIdPinError, EUsbStateHostHandleDropping); |
370 HandleHostProblemL(EUsbWatcherIdPinError, EUsbStateHostHandle); |
|
371 |
371 |
372 } |
372 } |
373 |
373 |
374 // From VBus observer |
374 // From VBus observer |
375 // --------------------------------------------------------------------------- |
375 // --------------------------------------------------------------------------- |
376 // |
376 // |
377 // --------------------------------------------------------------------------- |
377 // --------------------------------------------------------------------------- |
378 // |
378 // |
379 void CUsbOtgWatcher::VBusDownL() |
379 void CUsbOtgWatcher::VBusDownL() |
380 { |
380 { |
381 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusDownL" ) ); |
|
382 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
381 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
383 iHostState->VBusDownL(); |
382 iHostState->VBusDownL(); |
384 } |
383 } |
385 |
384 |
386 // --------------------------------------------------------------------------- |
385 // --------------------------------------------------------------------------- |
387 // |
386 // |
388 // --------------------------------------------------------------------------- |
387 // --------------------------------------------------------------------------- |
389 // |
388 // |
390 void CUsbOtgWatcher::VBusUpL() |
389 void CUsbOtgWatcher::VBusUpL() |
391 { |
390 { |
392 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusUpL" ) ); |
|
393 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
391 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
394 iHostState->VBusUpL(); |
392 iHostState->VBusUpL(); |
395 } |
393 } |
396 |
394 |
397 // --------------------------------------------------------------------------- |
395 // --------------------------------------------------------------------------- |
398 // |
396 // |
399 // --------------------------------------------------------------------------- |
397 // --------------------------------------------------------------------------- |
400 // |
398 // |
401 void CUsbOtgWatcher::VBusObserverErrorL(TInt aError) |
399 void CUsbOtgWatcher::VBusObserverErrorL(TInt aError) |
402 { |
400 { |
403 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusObserverErrorL" ) ); |
401 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
404 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
402 HandleHostProblemL(EUsbWatcherVBusObserverError, |
405 HandleHostProblemL(EUsbWatcherVBusObserverError, EUsbStateHostHandle); |
403 EUsbStateHostHandleDropping); |
406 } |
404 } |
407 |
405 |
408 // From OTG state observer |
406 // From OTG state observer |
409 // --------------------------------------------------------------------------- |
407 // --------------------------------------------------------------------------- |
410 // |
408 // |
411 // --------------------------------------------------------------------------- |
409 // --------------------------------------------------------------------------- |
412 // |
410 // |
413 void CUsbOtgWatcher::AIdleL() |
411 void CUsbOtgWatcher::AIdleL() |
414 { |
412 { |
415 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AIdleL" ) ); |
|
416 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
413 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
417 iHostState->AIdleL(); |
414 iHostState->AIdleL(); |
418 } |
415 } |
419 |
416 |
420 // --------------------------------------------------------------------------- |
417 // --------------------------------------------------------------------------- |
421 // |
418 // |
422 // --------------------------------------------------------------------------- |
419 // --------------------------------------------------------------------------- |
423 // |
420 // |
424 void CUsbOtgWatcher::AHostL() |
421 void CUsbOtgWatcher::AHostL() |
425 { |
422 { |
426 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AHostL" ) ); |
|
427 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
423 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
428 iHostState->AHostL(); |
424 iHostState->AHostL(); |
429 } |
425 } |
430 |
426 |
431 // --------------------------------------------------------------------------- |
427 // --------------------------------------------------------------------------- |
432 // |
428 // |
433 // --------------------------------------------------------------------------- |
429 // --------------------------------------------------------------------------- |
434 // |
430 // |
435 void CUsbOtgWatcher::APeripheralL() |
431 void CUsbOtgWatcher::APeripheralL() |
436 { |
432 { |
437 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::APeripheralL" ) ); |
|
438 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
433 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
439 iHostState->APeripheralL(); |
434 iHostState->APeripheralL(); |
440 } |
435 } |
441 |
436 |
442 // --------------------------------------------------------------------------- |
437 // --------------------------------------------------------------------------- |
443 // |
438 // |
444 // --------------------------------------------------------------------------- |
439 // --------------------------------------------------------------------------- |
445 // |
440 // |
446 void CUsbOtgWatcher::AVBusErrorL() |
441 void CUsbOtgWatcher::AVBusErrorL() |
447 { |
442 { |
448 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AVBusErrorL" ) ); |
|
449 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
443 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
450 iHostState->AVBusErrorL(); |
444 iHostState->AVBusErrorL(); |
451 } |
445 } |
452 |
446 |
453 // --------------------------------------------------------------------------- |
447 // --------------------------------------------------------------------------- |
454 // |
448 // |
455 // --------------------------------------------------------------------------- |
449 // --------------------------------------------------------------------------- |
456 // |
450 // |
457 void CUsbOtgWatcher::BIdleL() |
451 void CUsbOtgWatcher::BIdleL() |
458 { |
452 { |
459 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BIdleL" ) ); |
|
460 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
453 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
461 iHostState->BIdleL(); |
454 iHostState->BIdleL(); |
462 } |
455 } |
463 |
456 |
464 // --------------------------------------------------------------------------- |
457 // --------------------------------------------------------------------------- |
465 // |
458 // |
466 // --------------------------------------------------------------------------- |
459 // --------------------------------------------------------------------------- |
467 // |
460 // |
468 void CUsbOtgWatcher::BPeripheralL() |
461 void CUsbOtgWatcher::BPeripheralL() |
469 { |
462 { |
470 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BPeripheralL" ) ); |
|
471 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
463 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
472 iHostState->BPeripheralL(); |
464 iHostState->BPeripheralL(); |
473 } |
465 } |
474 |
466 |
475 // --------------------------------------------------------------------------- |
467 // --------------------------------------------------------------------------- |
476 // |
468 // |
477 // --------------------------------------------------------------------------- |
469 // --------------------------------------------------------------------------- |
478 // |
470 // |
479 void CUsbOtgWatcher::BHostL() |
471 void CUsbOtgWatcher::BHostL() |
480 { |
472 { |
481 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BHostL" ) ); |
|
482 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
473 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
483 iHostState->BHostL(); |
474 iHostState->BHostL(); |
484 } |
475 } |
485 |
476 |
486 // --------------------------------------------------------------------------- |
477 // --------------------------------------------------------------------------- |
487 // |
478 // |
488 // --------------------------------------------------------------------------- |
479 // --------------------------------------------------------------------------- |
489 // |
480 // |
490 void CUsbOtgWatcher::OtgStateErrorL(TInt aError) |
481 void CUsbOtgWatcher::OtgStateErrorL(TInt aError) |
491 { |
482 { |
492 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::OtgStateErrorL" ) ); |
483 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
493 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
484 HandleHostProblemL(EUsbWatcherOtgStateError, EUsbStateHostHandleDropping); |
494 HandleHostProblemL(EUsbWatcherOtgStateError, EUsbStateHostHandle); |
|
495 } |
485 } |
496 |
486 |
497 // From bus activity observer |
487 // From bus activity observer |
498 // --------------------------------------------------------------------------- |
488 // --------------------------------------------------------------------------- |
499 // |
489 // |
500 // --------------------------------------------------------------------------- |
490 // --------------------------------------------------------------------------- |
501 // |
491 // |
502 void CUsbOtgWatcher::BusIdleL() |
492 void CUsbOtgWatcher::BusIdleL() |
503 { |
493 { |
504 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusIdleL" ) ); |
|
505 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
494 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
506 iHostState->BusIdleL(); |
495 iHostState->BusIdleL(); |
507 } |
496 } |
508 |
497 |
509 // --------------------------------------------------------------------------- |
498 // --------------------------------------------------------------------------- |
510 // |
499 // |
511 // --------------------------------------------------------------------------- |
500 // --------------------------------------------------------------------------- |
512 // |
501 // |
513 void CUsbOtgWatcher::BusActiveL() |
502 void CUsbOtgWatcher::BusActiveL() |
514 { |
503 { |
515 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusActiveL" ) ); |
|
516 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
504 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
517 iHostState->BusActiveL(); |
505 iHostState->BusActiveL(); |
518 } |
506 } |
519 |
507 |
520 // --------------------------------------------------------------------------- |
508 // --------------------------------------------------------------------------- |
521 // |
509 // |
522 // --------------------------------------------------------------------------- |
510 // --------------------------------------------------------------------------- |
523 // |
511 // |
524 void CUsbOtgWatcher::BusActivityErrorL(TInt aError) |
512 void CUsbOtgWatcher::BusActivityErrorL(TInt aError) |
525 { |
513 { |
526 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusActivityErrorL" ) ); |
|
527 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
514 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
528 // no action, continue |
515 // no action, continue |
529 } |
516 } |
530 |
517 |
531 // From Host Event notification observer |
518 // From Host Event notification observer |
533 // |
520 // |
534 // --------------------------------------------------------------------------- |
521 // --------------------------------------------------------------------------- |
535 // |
522 // |
536 void CUsbOtgWatcher::DeviceAttachedL(TDeviceEventInformation aTdi) |
523 void CUsbOtgWatcher::DeviceAttachedL(TDeviceEventInformation aTdi) |
537 { |
524 { |
538 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DeviceAttachedL" ) ); |
|
539 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
525 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
540 iHostState->DeviceAttachedL(aTdi); |
526 iHostState->DeviceAttachedL(aTdi); |
541 } |
527 } |
542 |
528 |
543 // --------------------------------------------------------------------------- |
529 // --------------------------------------------------------------------------- |
544 // |
530 // |
545 // --------------------------------------------------------------------------- |
531 // --------------------------------------------------------------------------- |
546 // |
532 // |
547 void CUsbOtgWatcher::DeviceDetachedL(TDeviceEventInformation aTdi) |
533 void CUsbOtgWatcher::DeviceDetachedL(TDeviceEventInformation aTdi) |
548 { |
534 { |
549 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DeviceDetachedL" ) ); |
|
550 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
535 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
551 iHostState->DeviceDetachedL(aTdi); |
536 iHostState->DeviceDetachedL(aTdi); |
552 } |
537 } |
553 |
538 |
554 // --------------------------------------------------------------------------- |
539 // --------------------------------------------------------------------------- |
555 // |
540 // |
556 // --------------------------------------------------------------------------- |
541 // --------------------------------------------------------------------------- |
557 // |
542 // |
558 void CUsbOtgWatcher::DriverLoadSuccessL(TDeviceEventInformation aTdi) |
543 void CUsbOtgWatcher::DriverLoadSuccessL(TDeviceEventInformation aTdi) |
559 { |
544 { |
560 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DriverLoadSuccessL" ) ); |
|
561 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
545 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
562 iHostState->DriverLoadSuccessL(aTdi); |
546 iHostState->DriverLoadSuccessL(aTdi); |
563 } |
547 } |
564 |
548 |
565 // --------------------------------------------------------------------------- |
549 // --------------------------------------------------------------------------- |
566 // |
550 // |
567 // --------------------------------------------------------------------------- |
551 // --------------------------------------------------------------------------- |
568 // |
552 // |
569 void CUsbOtgWatcher::DriverLoadPartialSuccessL(TDeviceEventInformation aTdi) |
553 void CUsbOtgWatcher::DriverLoadPartialSuccessL(TDeviceEventInformation aTdi) |
570 { |
554 { |
571 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DriverLoadPartialSuccessL" ) ); |
|
572 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
555 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
573 iHostState->DriverLoadPartialSuccessL(aTdi); |
556 iHostState->DriverLoadPartialSuccessL(aTdi); |
574 } |
557 } |
575 |
558 |
576 // --------------------------------------------------------------------------- |
559 // --------------------------------------------------------------------------- |
577 // |
560 // |
578 // --------------------------------------------------------------------------- |
561 // --------------------------------------------------------------------------- |
579 // |
562 // |
580 void CUsbOtgWatcher::DriverLoadFailureL(TDeviceEventInformation aTdi) |
563 void CUsbOtgWatcher::DriverLoadFailureL(TDeviceEventInformation aTdi) |
581 { |
564 { |
582 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DriverLoadFailureL" ) ); |
|
583 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
565 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
584 iHostState->DriverLoadFailureL(aTdi); |
566 iHostState->DriverLoadFailureL(aTdi); |
585 } |
567 } |
586 |
568 |
587 // --------------------------------------------------------------------------- |
569 // --------------------------------------------------------------------------- |
588 // |
570 // |
589 // --------------------------------------------------------------------------- |
571 // --------------------------------------------------------------------------- |
590 // |
572 // |
591 void CUsbOtgWatcher::HostEventNotificationErrorL(TInt aError) |
573 void CUsbOtgWatcher::HostEventNotificationErrorL(TInt aError) |
592 { |
574 { |
593 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HostEventNotificationErrorL" ) ); |
575 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
594 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
576 HandleHostProblemL(EUsbWatcherHostEventNotificationError, |
595 HandleHostProblemL(EUsbWatcherHostEventNotificationError, EUsbStateHostHandle); |
577 EUsbStateHostHandleDropping); |
596 } |
578 } |
597 |
579 |
598 // From message notification observer |
580 // From message notification observer |
599 // --------------------------------------------------------------------------- |
581 // --------------------------------------------------------------------------- |
600 // |
582 // |
601 // --------------------------------------------------------------------------- |
583 // --------------------------------------------------------------------------- |
602 // |
584 // |
603 void CUsbOtgWatcher::MessageNotificationReceivedL(TInt aMessage) |
585 void CUsbOtgWatcher::MessageNotificationReceivedL(TInt aMessage) |
604 { |
586 { |
605 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::MessageNotificationReceivedL" ) ); |
|
606 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
587 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
607 iHostState->MessageNotificationReceivedL(aMessage); |
588 iHostState->MessageNotificationReceivedL(aMessage); |
608 } |
589 } |
609 |
590 |
610 // --------------------------------------------------------------------------- |
591 // --------------------------------------------------------------------------- |
611 // |
592 // |
612 // --------------------------------------------------------------------------- |
593 // --------------------------------------------------------------------------- |
613 // |
594 // |
614 void CUsbOtgWatcher::BadHubPositionL() |
595 void CUsbOtgWatcher::BadHubPositionL() |
615 { |
596 { |
616 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BadHubPositionL" ) ); |
|
617 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
597 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
618 iHostState->BadHubPositionL(); |
598 iHostState->BadHubPositionL(); |
619 } |
599 } |
620 |
600 |
621 // --------------------------------------------------------------------------- |
601 // --------------------------------------------------------------------------- |
622 // |
602 // |
623 // --------------------------------------------------------------------------- |
603 // --------------------------------------------------------------------------- |
624 // |
604 // |
625 void CUsbOtgWatcher::VBusErrorL() |
605 void CUsbOtgWatcher::VBusErrorL() |
626 { |
606 { |
627 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusErrorL" ) ); |
|
628 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
607 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
629 iHostState->VBusErrorL(); |
608 iHostState->VBusErrorL(); |
630 } |
609 } |
631 |
610 |
632 // --------------------------------------------------------------------------- |
611 // --------------------------------------------------------------------------- |
633 // |
612 // |
634 // --------------------------------------------------------------------------- |
613 // --------------------------------------------------------------------------- |
635 // |
614 // |
636 void CUsbOtgWatcher::SrpReceivedL() |
615 void CUsbOtgWatcher::SrpReceivedL() |
637 { |
616 { |
638 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SrpReceivedL" ) ); |
|
639 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
617 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
640 iHostState->SrpReceivedL(); |
618 iHostState->SrpReceivedL(); |
641 } |
619 } |
642 |
620 |
643 // --------------------------------------------------------------------------- |
621 // --------------------------------------------------------------------------- |
644 // |
622 // |
645 // --------------------------------------------------------------------------- |
623 // --------------------------------------------------------------------------- |
646 // |
624 // |
647 void CUsbOtgWatcher::SessionRequestedL() |
625 void CUsbOtgWatcher::SessionRequestedL() |
648 { |
626 { |
649 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SessionRequestedL" ) ); |
|
650 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
627 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
651 iHostState->SessionRequestedL(); |
628 iHostState->SessionRequestedL(); |
652 } |
629 } |
653 |
630 |
654 // --------------------------------------------------------------------------- |
631 // --------------------------------------------------------------------------- |
655 // |
632 // |
656 // --------------------------------------------------------------------------- |
633 // --------------------------------------------------------------------------- |
657 // |
634 // |
658 void CUsbOtgWatcher::MessageNotificationErrorL(TInt aError) |
635 void CUsbOtgWatcher::MessageNotificationErrorL(TInt aError) |
659 { |
636 { |
660 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::MessageNotificationErrorL" ) ); |
637 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
661 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
638 HandleHostProblemL(EUsbWatcherMessageNotificationError, |
662 HandleHostProblemL(EUsbWatcherMessageNotificationError, EUsbStateHostHandle); |
639 EUsbStateHostHandleDropping); |
663 } |
640 } |
664 |
641 |
665 // --------------------------------------------------------------------------- |
642 // --------------------------------------------------------------------------- |
666 // getters |
643 // getters |
667 // --------------------------------------------------------------------------- |
644 // --------------------------------------------------------------------------- |
888 // |
851 // |
889 // --------------------------------------------------------------------------- |
852 // --------------------------------------------------------------------------- |
890 // |
853 // |
891 void CUsbOtgWatcher::UsbServiceControlReqCompletedL(TInt aError) |
854 void CUsbOtgWatcher::UsbServiceControlReqCompletedL(TInt aError) |
892 { |
855 { |
893 FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompleted Error returned by UsbServiceControl = %d" ), aError)); |
856 LOG_FUNC |
894 |
857 |
895 switch(aError) |
858 LOG1( "aError = %d" , aError); |
896 { |
859 |
897 case KErrInUse: |
860 switch (aError) |
898 // usb services already started (this might happen if more than one idpin on event come) |
861 { |
899 { |
862 case KErrInUse: |
900 return; |
863 // usb services already started (this might happen if more than one idpin on event come) |
901 } |
|
902 |
|
903 case KErrNone: |
|
904 { |
|
905 break; // do normal routine |
|
906 } |
|
907 |
|
908 default: // handle the issue |
|
909 { |
|
910 if(IsDeviceA()) // if there is no cable, give up |
|
911 { |
864 { |
912 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle); |
865 return; |
913 } |
866 } |
914 return; |
867 |
915 } |
868 case KErrNone: |
916 } |
869 { |
|
870 break; // do normal routine |
|
871 } |
|
872 |
|
873 default: // handle the issue |
|
874 { |
|
875 if (iUsbServiceRequest == CUsbServiceControl::EStartUsbService) // Handle only start issues |
|
876 { |
|
877 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, |
|
878 EUsbStateHostHandleDropping); |
|
879 } |
|
880 |
|
881 iUsbServiceRequest = CUsbServiceControl::ERequestUndefined; |
|
882 return; |
|
883 } |
|
884 } |
|
885 |
|
886 iUsbServiceRequest = CUsbServiceControl::ERequestUndefined; |
917 |
887 |
918 TUsbServiceState serviceState; |
888 TUsbServiceState serviceState; |
919 TInt err = iUsb.GetServiceState(serviceState); |
889 TInt err = iUsb.GetServiceState(serviceState); |
920 |
890 |
921 if (KErrNone != err) |
891 if (KErrNone != err) |
922 { |
892 { |
923 FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompleted Error when requesting GetServiceState = %d" ), err)); |
893 LOG1( "Error when requesting GetServiceState = %d" , err); |
924 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle); |
894 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, |
|
895 EUsbStateHostHandleDropping); |
925 return; |
896 return; |
926 } |
897 } |
927 |
898 |
928 switch (serviceState) |
899 switch (serviceState) |
929 { |
900 { |
930 case EUsbServiceIdle: // just stopped usb service |
901 case EUsbServiceIdle: // just stopped usb service |
931 { |
902 { |
932 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceIdle" ) ); |
903 LOG("UsbServiceState == EUsbServiceIdle" ); |
933 // do nothing |
904 // do nothing |
934 break; |
905 break; |
935 } |
906 } |
936 |
907 |
937 case EUsbServiceStarted: // just started usb service |
908 case EUsbServiceStarted: // just started usb service |
938 { |
909 { |
939 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStarted" ) ); |
910 LOG( "UsbServiceState == EUsbServiceStarted" ); |
940 |
911 |
941 iHostState = iStates[EUsbStateHostAInitiate]; |
912 ChangeHostStateL(EUsbStateHostAInitiate); |
942 |
|
943 iHostState->JustAdvancedToThisStateL(); // do any initial activity, once advanced to the state |
|
944 |
913 |
945 break; |
914 break; |
946 } |
915 } |
947 case EUsbServiceStarting: |
916 case EUsbServiceStarting: |
948 { |
917 { |
949 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStarting" ) ); |
918 LOG("UsbServiceState == EUsbServiceStarting" ); |
950 // should not receive that, due to call back is called when service stopped or started |
919 // should not receive that, due to call back is called when service stopped or started |
951 // therefore scream |
920 // therefore scream |
952 // no break statement here |
921 // no break statement here |
953 } |
922 } |
954 case EUsbServiceStopping: |
923 case EUsbServiceStopping: |
955 { |
924 { |
956 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStopping" ) ); |
925 LOG("UsbServiceState == EUsbServiceStopping" ); |
957 // should not receive that, due to call back is called when service stopped or started |
926 // should not receive that, due to call back is called when service stopped or started |
958 // therefore scream |
927 // therefore scream |
959 // no break statement here |
928 // no break statement here |
960 } |
929 } |
961 case EUsbServiceFatalError: |
930 case EUsbServiceFatalError: |
962 { |
931 { |
963 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceFatalError" ) ); |
932 LOG( "UsbServiceState == EUsbServiceFatalError" ); |
964 Panic(EUnexpectedUsbServiceState); |
933 Panic(EUnexpectedUsbServiceState); |
965 break; |
934 break; |
966 } |
935 } |
967 |
936 |
968 default: |
937 default: |
969 { |
938 { |
970 Panic(EUnknownUsbServiceState); |
939 Panic(EUnknownUsbServiceState); |
971 } |
940 } |
972 } |
941 } |
973 |
|
974 } |
942 } |
975 |
943 |
976 // --------------------------------------------------------------------------- |
944 // --------------------------------------------------------------------------- |
977 // |
945 // |
978 // --------------------------------------------------------------------------- |
946 // --------------------------------------------------------------------------- |
979 // |
947 // |
980 TInt CUsbOtgWatcher::SelfTestL() |
948 TInt CUsbOtgWatcher::SelfTestL() |
981 { |
949 { |
982 #ifdef _DEBUG |
950 #ifdef _DEBUG |
983 |
951 LOG_FUNC |
984 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Creating observers." ) ); |
|
985 |
952 |
986 // create all the observers |
953 // create all the observers |
987 iIdPinObserver = CUsbIdPinObserver::NewL(); |
954 iIdPinObserver = CUsbIdPinObserver::NewL(); |
988 iVBusObserver = CUsbVBusObserver::NewL(); |
955 iVBusObserver = CUsbVBusObserver::NewL(); |
989 iOtgStateObserver = CUsbOtgStateObserver::NewL(); |
956 iOtgStateObserver = CUsbOtgStateObserver::NewL(); |
990 iBusActivityObserver = |
957 iBusActivityObserver = CUsbBusActivityObserver::NewL(); |
991 CUsbBusActivityObserver::NewL(); |
958 iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL( |
992 iHostEventNotificationObserver = |
959 &iUsb); |
993 CUsbHostEventNotificationObserver::NewL(&iUsb); |
960 iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL( |
994 iMessageNotificationObserver = |
961 &iUsb); |
995 CUsbMessageNotificationObserver::NewL(&iUsb); |
962 |
996 |
963 LOG( "Observers getters" ); |
997 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Observers getters." ) ); |
|
998 |
964 |
999 if (iIdPinObserver != IdPinObserver()) |
965 if (iIdPinObserver != IdPinObserver()) |
1000 { |
966 { |
1001 User::Leave(KErrGeneral); |
967 User::Leave(KErrGeneral); |
1002 } |
968 } |
1019 if (iMessageNotificationObserver != MessageNotificationObserver()) |
985 if (iMessageNotificationObserver != MessageNotificationObserver()) |
1020 { |
986 { |
1021 User::Leave(KErrGeneral); |
987 User::Leave(KErrGeneral); |
1022 } |
988 } |
1023 |
989 |
1024 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Observers destructors." ) ); |
990 LOG( "Observers destructors" ); |
1025 |
991 |
1026 // idpinobserver is deleted later |
992 // idpinobserver is deleted later |
1027 // Vbus observer is deleted later |
993 // Vbus observer is deleted later |
1028 |
994 |
1029 delete iOtgStateObserver; |
995 delete iOtgStateObserver; |
1030 iOtgStateObserver = 0; |
996 iOtgStateObserver = 0; |
1031 delete iBusActivityObserver; |
997 delete iBusActivityObserver; |
1032 iBusActivityObserver = 0; |
998 iBusActivityObserver = 0; |
1033 delete iHostEventNotificationObserver; |
999 delete iHostEventNotificationObserver; |
1034 iHostEventNotificationObserver = 0; |
1000 iHostEventNotificationObserver = 0; |
1035 delete iMessageNotificationObserver; |
1001 delete iMessageNotificationObserver; |
1036 iMessageNotificationObserver = 0; |
1002 iMessageNotificationObserver = 0; |
1037 |
1003 |
1038 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Creating states." ) ); |
1004 LOG("Creating states"); |
1039 |
1005 |
1040 User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(this))); |
1006 User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(*this))); |
1041 User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this))); |
1007 User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(*this))); |
1042 User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this))); |
1008 User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(*this))); |
1043 User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this))); |
1009 User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(*this))); |
1044 User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this))); |
1010 User::LeaveIfError(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL( |
1045 User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this))); |
1011 *this))); |
1046 User::LeaveIfError(iStates.Append(CUsbStateHostDelayHandle::NewL(this))); |
1012 User::LeaveIfError(iStates.Append( |
1047 |
1013 CUsbStateHostDelayNotAttachedHandle::NewL(*this))); |
1048 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check State()" ) ); |
1014 User::LeaveIfError(iStates.Append( |
|
1015 CUsbStateHostHandleDropping::NewL(*this))); |
|
1016 |
|
1017 LOG("Check State()" ); |
1049 |
1018 |
1050 if (iStates[EUsbStateHostAInitiate] != State(EUsbStateHostAInitiate)) |
1019 if (iStates[EUsbStateHostAInitiate] != State(EUsbStateHostAInitiate)) |
1051 { |
1020 { |
1052 User::Leave(KErrGeneral); |
1021 User::Leave(KErrGeneral); |
1053 } |
1022 } |
1054 |
1023 |
1055 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check CurrentHostState()" ) ); |
1024 LOG("Check CurrentHostState()" ); |
1056 |
1025 |
1057 iHostState = iStates[EUsbStateHostAInitiate]; |
1026 iHostState = iStates[EUsbStateHostAInitiate]; |
1058 |
1027 |
1059 if (iStates[EUsbStateHostAInitiate] != CurrentHostState()) |
1028 if (iStates[EUsbStateHostAInitiate] != CurrentHostState()) |
1060 { |
1029 { |
1061 User::Leave(KErrGeneral); |
1030 User::Leave(KErrGeneral); |
1062 } |
1031 } |
1063 |
1032 |
1064 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL NotifManager and WarningNotifier." ) ); |
1033 LOG("NotifManager and WarningNotifier." ); |
1065 |
1034 |
1066 CUsbNotifManager* usbnotifmanager = CUsbNotifManager::NewL(this); |
1035 CUsbNotifManager* usbnotifmanager = CUsbNotifManager::NewL(*this); |
1067 RNotifier rnotifier; |
1036 RNotifier rnotifier; |
1068 User::LeaveIfError(rnotifier.Connect()); |
1037 User::LeaveIfError(rnotifier.Connect()); |
1069 CUsbWarningNotifier* usbnotifier = CUsbWarningNotifier::NewL(rnotifier, |
1038 CUsbWarningNotifier* usbnotifier = CUsbWarningNotifier::NewL(rnotifier, |
1070 usbnotifmanager, EUsbOtgPartiallySupportedDevice); |
1039 *usbnotifmanager, EUsbOtgPartiallySupportedDevice); |
1071 usbnotifier->IsFeedbackNeeded(); |
1040 usbnotifier->IsFeedbackNeeded(); |
1072 |
1041 |
1073 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL NotifManager and WarningNotifier destruction." ) ); |
1042 LOG( "NotifManager and WarningNotifier destruction." ); |
1074 |
1043 |
1075 delete usbnotifier; |
1044 delete usbnotifier; |
1076 rnotifier.Close(); |
1045 rnotifier.Close(); |
1077 delete usbnotifmanager; |
1046 delete usbnotifmanager; |
1078 |
1047 |
1079 // VBus observer is deleted here, due to it is used by usbnotifmanager.usbindicatornotifier |
1048 // VBus observer is deleted here, due to it is used by usbnotifmanager.usbindicatornotifier |
1080 delete iVBusObserver; |
1049 delete iVBusObserver; |
1081 iVBusObserver = 0; |
1050 iVBusObserver = 0; |
1082 |
1051 |
1083 // id pin observer is deleted here due to it is used by usbnotifmanager.usbindicatornotifier |
1052 // id pin observer is deleted here due to it is used by usbnotifmanager.usbindicatornotifier |
1084 delete iIdPinObserver; |
1053 delete iIdPinObserver; |
1085 iIdPinObserver = 0; |
1054 iIdPinObserver = 0; |
1086 |
1055 |
1087 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Destructing states." ) ); |
1056 LOG("Destructing states"); |
1088 |
1057 |
1089 iStates.ResetAndDestroy(); |
1058 iStates.ResetAndDestroy(); |
1090 |
1059 |
1091 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check UsbServiceControl" ) ); |
1060 LOG( "Check UsbServiceControl" ); |
1092 |
1061 |
1093 CUsbServiceControl* usbServiceControl = CUsbServiceControl::NewL(this, |
1062 CUsbServiceControl* usbServiceControl = CUsbServiceControl::NewL(*this, |
1094 iUsb); |
1063 iUsb); |
1095 usbServiceControl->RunError(KErrNone); |
1064 usbServiceControl->RunError(KErrNone); |
1096 delete usbServiceControl; |
1065 delete usbServiceControl; |
1097 |
1066 |
1098 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL All completed OK." ) ); |
1067 LOG("All completed OK" ); |
1099 #endif |
1068 #endif |
1100 return KErrNone; |
1069 return KErrNone; |
1101 |
1070 |
1102 } |
1071 } |
1103 |
1072 |
1104 // --------------------------------------------------------------------------- |
1073 // --------------------------------------------------------------------------- |
1105 // |
1074 // |
1106 // --------------------------------------------------------------------------- |
1075 // --------------------------------------------------------------------------- |
1107 // |
1076 // |
1108 void CUsbOtgWatcher::SubscribeL(MUsbOtgWatcherStateObserver& aObserver) |
1077 void CUsbOtgWatcher::SubscribeL(MUsbOtgWatcherStateObserver& aObserver) |
1109 { |
1078 { |
1110 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SubscribeL" ) ); |
1079 LOG_FUNC |
1111 |
1080 |
1112 // check if the same observer already exist in a list |
1081 // check if the same observer already exist in a list |
1113 if(KErrNotFound != iOtgStateObservers.Find(&aObserver)) |
1082 if (KErrNotFound != iOtgStateObservers.Find(&aObserver)) |
1114 { |
1083 { |
1115 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SubscribeL Observer already exists." ) ); |
1084 LOG( "Observer already exists" ); |
1116 Panic(EObserverAlreadyExists); |
1085 Panic(EObserverAlreadyExists); |
1117 return; |
1086 return; |
1118 } |
1087 } |
1119 iOtgStateObservers.AppendL(&aObserver); |
1088 iOtgStateObservers.AppendL(&aObserver); |
1120 |
1089 |
1121 } |
1090 } |
1122 |
1091 |
1123 // --------------------------------------------------------------------------- |
1092 // --------------------------------------------------------------------------- |
1124 // |
1093 // |
1125 // --------------------------------------------------------------------------- |
1094 // --------------------------------------------------------------------------- |
1126 // |
1095 // |
1127 void CUsbOtgWatcher::UnsubscribeL(MUsbOtgWatcherStateObserver& aObserver) |
1096 void CUsbOtgWatcher::UnsubscribeL(MUsbOtgWatcherStateObserver& aObserver) |
1128 { |
1097 { |
1129 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL" ) ); |
1098 LOG_FUNC |
1130 TInt i(iOtgStateObservers.Find(&aObserver)); |
1099 |
1131 if(KErrNotFound == i) |
1100 TInt i(iOtgStateObservers.Find(&aObserver)); |
1132 { |
1101 if (KErrNotFound == i) |
1133 FLOG( _L( "[USBOTGWATCHER]\tCUsbIdPinObserver::UnsubscribeL Observer not found." ) ); |
1102 { |
1134 Panic(ECanNotFindUsbOtgWatcherStateObserver); |
1103 LOG( "Observer not found" ); |
1135 return; |
1104 Panic(ECanNotFindUsbOtgWatcherStateObserver); |
1136 } |
1105 return; |
1137 |
1106 } |
1138 iOtgStateObservers.Remove(i); |
1107 |
1139 } |
1108 iOtgStateObservers.Remove(i); |
|
1109 } |