26 #include "cusbstatehostainitiate.h" |
26 #include "cusbstatehostainitiate.h" |
27 #include "cusbstatehostahost.h" |
27 #include "cusbstatehostahost.h" |
28 #include "cusbstatehostaperipheral.h" |
28 #include "cusbstatehostaperipheral.h" |
29 #include "cusbstatehostaidle.h" |
29 #include "cusbstatehostaidle.h" |
30 #include "cusbstatehosthandle.h" |
30 #include "cusbstatehosthandle.h" |
|
31 #include "cusbstatehostdelayhandle.h" |
|
32 #include "cusbstatehostundefined.h" |
31 |
33 |
32 #include "cusbwarningnotifier.h" |
34 #include "cusbwarningnotifier.h" |
33 |
35 |
34 #ifndef STIF |
36 #ifndef STIF |
35 #include "cusbnotifmanager.h" |
37 #include "cusbnotifmanager.h" |
77 KUsbWatcherPeripheralIsNotConnected ) ); |
79 KUsbWatcherPeripheralIsNotConnected ) ); |
78 #endif |
80 #endif |
79 |
81 |
80 iUsbServiceControl = CUsbServiceControl::NewL(this, iUsb); |
82 iUsbServiceControl = CUsbServiceControl::NewL(this, iUsb); |
81 |
83 |
82 User::LeaveIfError(iStates.Append(CUsbState::NewL(this))); |
84 User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(this))); |
83 User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this))); |
85 User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this))); |
84 User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this))); |
86 User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this))); |
85 User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this))); |
87 User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this))); |
86 User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this))); |
88 User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this))); |
87 User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this))); |
89 User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this))); |
|
90 User::LeaveIfError(iStates.Append(CUsbStateHostDelayHandle::NewL(this))); |
88 |
91 |
89 iIdPinObserver = CUsbIdPinObserver::NewL(); |
92 iIdPinObserver = CUsbIdPinObserver::NewL(); |
90 iVBusObserver = CUsbVBusObserver::NewL(); |
93 iVBusObserver = CUsbVBusObserver::NewL(); |
91 iOtgStateObserver = CUsbOtgStateObserver::NewL(); |
94 iOtgStateObserver = CUsbOtgStateObserver::NewL(); |
92 iBusActivityObserver = CUsbBusActivityObserver::NewL(); |
95 iBusActivityObserver = CUsbBusActivityObserver::NewL(); |
93 iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL( |
96 iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL( |
94 &iUsb); |
97 &iUsb); |
95 iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL( |
98 iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL( |
96 &iUsb); |
99 &iUsb); |
97 |
100 |
98 iHostState = iStates[EUsbStateUndefined]; |
101 iHostState = iStates[EUsbStateHostUndefined]; |
99 |
102 |
100 // Notif manager must be created at least after VBus observer and iHostState initialization |
103 // Notif manager must be created at least after VBus observer and iHostState initialization |
101 // to allow USb indicator subscribe to its notifications at construction and check their's current states |
104 // to allow USb indicator subscribe to its notifications at construction and check their's current states |
102 iNotifManager = CUsbNotifManager::NewL(this); |
105 iNotifManager = CUsbNotifManager::NewL(this); |
103 |
106 |
104 iIdPinObserver->SubscribeL(this); |
107 iVBusObserver->SubscribeL(*this); |
|
108 iOtgStateObserver->SubscribeL(*this); |
|
109 iBusActivityObserver->SubscribeL(*this); |
|
110 iHostEventNotificationObserver->SubscribeL(*this); |
|
111 iMessageNotificationObserver->SubscribeL(*this); |
|
112 iIdPinObserver->SubscribeL(*this); |
105 |
113 |
106 if (CUsbIdPinObserver::EIdPinOn == iIdPinObserver->IdPin()) |
114 if (CUsbIdPinObserver::EIdPinOn == iIdPinObserver->IdPin()) |
107 { |
115 { |
108 StartSessionL(); |
116 StartSessionL(); |
109 } |
117 } |
149 RProperty::Delete( KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected ); |
157 RProperty::Delete( KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected ); |
150 #endif |
158 #endif |
151 |
159 |
152 // delete Notif manager before VBus observer, due to USB indicator observes VBus |
160 // delete Notif manager before VBus observer, due to USB indicator observes VBus |
153 delete iNotifManager; |
161 delete iNotifManager; |
|
162 |
|
163 if(iIdPinObserver) |
|
164 { |
|
165 TRAP_IGNORE(iIdPinObserver->UnsubscribeL(*this)); |
|
166 } |
|
167 |
|
168 if(iVBusObserver) |
|
169 { |
|
170 TRAP_IGNORE(iVBusObserver->UnsubscribeL(*this)); |
|
171 } |
|
172 if(iOtgStateObserver) |
|
173 { |
|
174 TRAP_IGNORE(iOtgStateObserver->UnsubscribeL(*this)); |
|
175 } |
|
176 if(iBusActivityObserver) |
|
177 { |
|
178 TRAP_IGNORE(iBusActivityObserver->UnsubscribeL(*this)); |
|
179 } |
|
180 if(iHostEventNotificationObserver) |
|
181 { |
|
182 TRAP_IGNORE(iHostEventNotificationObserver->UnsubscribeL(*this)); |
|
183 } |
|
184 if(iMessageNotificationObserver) |
|
185 { |
|
186 TRAP_IGNORE(iMessageNotificationObserver->UnsubscribeL(*this)); |
|
187 } |
154 |
188 |
155 delete iIdPinObserver; |
189 delete iIdPinObserver; |
156 delete iVBusObserver; |
190 delete iVBusObserver; |
157 delete iOtgStateObserver; |
191 delete iOtgStateObserver; |
158 delete iBusActivityObserver; |
192 delete iBusActivityObserver; |
257 { |
291 { |
258 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL" ) ); |
292 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL" ) ); |
259 |
293 |
260 if (!CanStartSessionL()) |
294 if (!CanStartSessionL()) |
261 { |
295 { |
262 HandleHostProblemL(EUsbWatcherErrorInConnection); |
296 HandleHostProblemL(EUsbWatcherErrorInConnection, EUsbStateHostHandle); |
263 return; |
297 return; |
264 } |
298 } |
265 |
299 |
266 TInt err = iUsbServiceControl->StartL(iPersonalityId); |
300 TInt err = iUsbServiceControl->StartL(iPersonalityId); |
267 if (KErrNone != err) |
301 if (KErrNone != err) |
268 { |
302 { |
269 FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL Can not start usb services. reason = %d" ), err)); |
303 FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL Can not start usb services. reason = %d" ), err)); |
270 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices); |
304 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle); |
271 return; |
305 return; |
272 } |
306 } |
273 |
307 |
274 // call back from iUsbServiceControl->Start(iPersonalityId) call is UsbServiceControlReqCompletedL(TInt aError) |
308 // call back from iUsbServiceControl->Start(iPersonalityId) call is UsbServiceControlReqCompletedL(TInt aError) |
275 // so, continue there if everything is OK |
309 // so, continue there if everything is OK |
278 |
312 |
279 // --------------------------------------------------------------------------- |
313 // --------------------------------------------------------------------------- |
280 // |
314 // |
281 // --------------------------------------------------------------------------- |
315 // --------------------------------------------------------------------------- |
282 // |
316 // |
283 void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf) |
317 void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf, TUsbStateIds aInState ) |
284 { |
318 { |
285 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HandleProblemL" ) ); |
319 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HandleProblemL" ) ); |
286 HostHandle()->SetWhat(aWhatKindOf); |
320 HostHandle(aInState)->SetWhat(aWhatKindOf); |
287 ChangeHostStateL(EUsbStateHostHandle); |
321 ChangeHostStateL(aInState); |
288 } |
322 } |
289 |
323 |
290 // --------------------------------------------------------------------------- |
324 // --------------------------------------------------------------------------- |
291 // |
325 // |
292 // --------------------------------------------------------------------------- |
326 // --------------------------------------------------------------------------- |
303 // |
337 // |
304 void CUsbOtgWatcher::IdPinOffL() |
338 void CUsbOtgWatcher::IdPinOffL() |
305 { |
339 { |
306 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL" ) ); |
340 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL" ) ); |
307 |
341 |
308 // for example, USB failed to start |
342 ChangeHostStateL(EUsbStateHostUndefined); |
309 if(NULL == iHostState) return; |
|
310 |
|
311 iVBusObserver->UnsubscribeL(this); |
|
312 iOtgStateObserver->UnsubscribeL(this); |
|
313 iBusActivityObserver->UnsubscribeL(this); |
|
314 iHostEventNotificationObserver->UnsubscribeL(this); |
|
315 iMessageNotificationObserver->UnsubscribeL(this); |
|
316 |
|
317 iHostState->JustBeforeLeavingThisStateL(); |
|
318 |
|
319 iHostState = NULL; |
|
320 |
343 |
321 iNotifManager->CloseAllNotifiers(); |
344 iNotifManager->CloseAllNotifiers(); |
322 |
345 |
323 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL Before DisableFunctionDriverLoad " ) ); |
346 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL Before DisableFunctionDriverLoad " ) ); |
324 Usb().DisableFunctionDriverLoading(); |
347 Usb().DisableFunctionDriverLoading(); |
342 // |
365 // |
343 void CUsbOtgWatcher::IdPinErrorL(TInt aError) |
366 void CUsbOtgWatcher::IdPinErrorL(TInt aError) |
344 { |
367 { |
345 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinErrorL" ) ); |
368 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinErrorL" ) ); |
346 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
369 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
347 HandleHostProblemL(EUsbWatcherIdPinError); |
370 HandleHostProblemL(EUsbWatcherIdPinError, EUsbStateHostHandle); |
348 |
371 |
349 } |
372 } |
350 |
373 |
351 // From VBus observer |
374 // From VBus observer |
352 // --------------------------------------------------------------------------- |
375 // --------------------------------------------------------------------------- |
377 // |
400 // |
378 void CUsbOtgWatcher::VBusObserverErrorL(TInt aError) |
401 void CUsbOtgWatcher::VBusObserverErrorL(TInt aError) |
379 { |
402 { |
380 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusObserverErrorL" ) ); |
403 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusObserverErrorL" ) ); |
381 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
404 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
382 HandleHostProblemL(EUsbWatcherVBusObserverError); |
405 HandleHostProblemL(EUsbWatcherVBusObserverError, EUsbStateHostHandle); |
383 } |
406 } |
384 |
407 |
385 // From OTG state observer |
408 // From OTG state observer |
386 // --------------------------------------------------------------------------- |
409 // --------------------------------------------------------------------------- |
387 // |
410 // |
466 // |
489 // |
467 void CUsbOtgWatcher::OtgStateErrorL(TInt aError) |
490 void CUsbOtgWatcher::OtgStateErrorL(TInt aError) |
468 { |
491 { |
469 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::OtgStateErrorL" ) ); |
492 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::OtgStateErrorL" ) ); |
470 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
493 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
471 HandleHostProblemL(EUsbWatcherOtgStateError); |
494 HandleHostProblemL(EUsbWatcherOtgStateError, EUsbStateHostHandle); |
472 } |
495 } |
473 |
496 |
474 // From bus activity observer |
497 // From bus activity observer |
475 // --------------------------------------------------------------------------- |
498 // --------------------------------------------------------------------------- |
476 // |
499 // |
567 // |
590 // |
568 void CUsbOtgWatcher::HostEventNotificationErrorL(TInt aError) |
591 void CUsbOtgWatcher::HostEventNotificationErrorL(TInt aError) |
569 { |
592 { |
570 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HostEventNotificationErrorL" ) ); |
593 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HostEventNotificationErrorL" ) ); |
571 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
594 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
572 HandleHostProblemL(EUsbWatcherHostEventNotificationError); |
595 HandleHostProblemL(EUsbWatcherHostEventNotificationError, EUsbStateHostHandle); |
573 } |
596 } |
574 |
597 |
575 // From message notification observer |
598 // From message notification observer |
576 // --------------------------------------------------------------------------- |
599 // --------------------------------------------------------------------------- |
577 // |
600 // |
634 // |
657 // |
635 void CUsbOtgWatcher::MessageNotificationErrorL(TInt aError) |
658 void CUsbOtgWatcher::MessageNotificationErrorL(TInt aError) |
636 { |
659 { |
637 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::MessageNotificationErrorL" ) ); |
660 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::MessageNotificationErrorL" ) ); |
638 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
661 __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState)); |
639 HandleHostProblemL(EUsbWatcherMessageNotificationError); |
662 HandleHostProblemL(EUsbWatcherMessageNotificationError, EUsbStateHostHandle); |
640 } |
663 } |
641 |
664 |
642 // --------------------------------------------------------------------------- |
665 // --------------------------------------------------------------------------- |
643 // getters |
666 // getters |
644 // --------------------------------------------------------------------------- |
667 // --------------------------------------------------------------------------- |
733 |
756 |
734 // --------------------------------------------------------------------------- |
757 // --------------------------------------------------------------------------- |
735 // |
758 // |
736 // --------------------------------------------------------------------------- |
759 // --------------------------------------------------------------------------- |
737 // |
760 // |
738 CUsbStateHostHandle* CUsbOtgWatcher::HostHandle() const |
761 CUsbStateHostHandle* CUsbOtgWatcher::HostHandle(TUsbStateIds aInState) const |
739 { |
762 { |
740 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HostHandle" ) ); |
763 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HostHandle" ) ); |
741 __ASSERT_DEBUG(iStates[EUsbStateHostHandle] != NULL, Panic(EBadState)); |
764 __ASSERT_DEBUG(iStates[aInState] != NULL, Panic(EBadState)); |
742 return (CUsbStateHostHandle*) iStates[EUsbStateHostHandle]; |
765 |
|
766 return (CUsbStateHostHandle*) iStates[aInState]; |
743 } |
767 } |
744 |
768 |
745 // --------------------------------------------------------------------------- |
769 // --------------------------------------------------------------------------- |
746 // |
770 // |
747 // --------------------------------------------------------------------------- |
771 // --------------------------------------------------------------------------- |
881 break; // do normal routine |
905 break; // do normal routine |
882 } |
906 } |
883 |
907 |
884 default: // handle the issue |
908 default: // handle the issue |
885 { |
909 { |
886 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices); |
910 if(IsDeviceA()) // if there is no cable, give up |
|
911 { |
|
912 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle); |
|
913 } |
887 return; |
914 return; |
888 } |
915 } |
889 } |
916 } |
890 |
917 |
891 TUsbServiceState serviceState; |
918 TUsbServiceState serviceState; |
892 TInt err = iUsb.GetServiceState(serviceState); |
919 TInt err = iUsb.GetServiceState(serviceState); |
893 |
920 |
894 if (KErrNone != err) |
921 if (KErrNone != err) |
895 { |
922 { |
896 FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompleted Error when requesting GetServiceState = %d" ), err)); |
923 FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompleted Error when requesting GetServiceState = %d" ), err)); |
897 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices); |
924 HandleHostProblemL(EUsbWatcherCanNotStartUsbServices, EUsbStateHostHandle); |
898 return; |
925 return; |
899 } |
926 } |
900 |
927 |
901 switch (serviceState) |
928 switch (serviceState) |
902 { |
929 { |
913 |
940 |
914 iHostState = iStates[EUsbStateHostAInitiate]; |
941 iHostState = iStates[EUsbStateHostAInitiate]; |
915 |
942 |
916 iHostState->JustAdvancedToThisStateL(); // do any initial activity, once advanced to the state |
943 iHostState->JustAdvancedToThisStateL(); // do any initial activity, once advanced to the state |
917 |
944 |
918 iVBusObserver->SubscribeL(this); |
|
919 iOtgStateObserver->SubscribeL(this); |
|
920 iBusActivityObserver->SubscribeL(this); |
|
921 iHostEventNotificationObserver->SubscribeL(this); |
|
922 iMessageNotificationObserver->SubscribeL(this); |
|
923 |
|
924 break; |
945 break; |
925 } |
946 } |
926 case EUsbServiceStarting: |
947 case EUsbServiceStarting: |
927 { |
948 { |
928 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStarting" ) ); |
949 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStarting" ) ); |
929 // should not receive that, due to call back is called when service stopped or started |
950 // should not receive that, due to call back is called when service stopped or started |
930 // therefore scream |
951 // therefore scream |
|
952 // no break statement here |
931 } |
953 } |
932 case EUsbServiceStopping: |
954 case EUsbServiceStopping: |
933 { |
955 { |
934 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStopping" ) ); |
956 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceStopping" ) ); |
935 // should not receive that, due to call back is called when service stopped or started |
957 // should not receive that, due to call back is called when service stopped or started |
936 // therefore scream |
958 // therefore scream |
|
959 // no break statement here |
937 } |
960 } |
938 case EUsbServiceFatalError: |
961 case EUsbServiceFatalError: |
939 { |
962 { |
940 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceFatalError" ) ); |
963 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UsbServiceControlReqCompletedL UsbServiceState == EUsbServiceFatalError" ) ); |
941 Panic(EUnexpectedUsbServiceState); |
964 Panic(EUnexpectedUsbServiceState); |
1012 delete iMessageNotificationObserver; |
1035 delete iMessageNotificationObserver; |
1013 iMessageNotificationObserver = 0; |
1036 iMessageNotificationObserver = 0; |
1014 |
1037 |
1015 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Creating states." ) ); |
1038 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Creating states." ) ); |
1016 |
1039 |
1017 User::LeaveIfError(iStates.Append(CUsbState::NewL(this))); |
1040 User::LeaveIfError(iStates.Append(CUsbStateHostUndefined::NewL(this))); |
1018 User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this))); |
1041 User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this))); |
1019 User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this))); |
1042 User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this))); |
1020 User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this))); |
1043 User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this))); |
1021 User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this))); |
1044 User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this))); |
1022 User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this))); |
1045 User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this))); |
|
1046 User::LeaveIfError(iStates.Append(CUsbStateHostDelayHandle::NewL(this))); |
1023 |
1047 |
1024 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check State()" ) ); |
1048 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SelfTestL Check State()" ) ); |
1025 |
1049 |
1026 if (iStates[EUsbStateHostAInitiate] != State(EUsbStateHostAInitiate)) |
1050 if (iStates[EUsbStateHostAInitiate] != State(EUsbStateHostAInitiate)) |
1027 { |
1051 { |
1079 |
1103 |
1080 // --------------------------------------------------------------------------- |
1104 // --------------------------------------------------------------------------- |
1081 // |
1105 // |
1082 // --------------------------------------------------------------------------- |
1106 // --------------------------------------------------------------------------- |
1083 // |
1107 // |
1084 void CUsbOtgWatcher::SubscribeL(MUsbOtgWatcherStateObserver* aObserver) |
1108 void CUsbOtgWatcher::SubscribeL(MUsbOtgWatcherStateObserver& aObserver) |
1085 { |
1109 { |
1086 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SubscribeL" ) ); |
1110 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SubscribeL" ) ); |
1087 |
1111 |
1088 User::LeaveIfError(iOtgStateObservers.Append(aObserver)); |
1112 // check if the same observer already exist in a list |
1089 |
1113 if(KErrNotFound != iOtgStateObservers.Find(&aObserver)) |
1090 } |
1114 { |
1091 |
1115 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SubscribeL Observer already exists." ) ); |
1092 // --------------------------------------------------------------------------- |
1116 Panic(EObserverAlreadyExists); |
1093 // |
1117 return; |
1094 // --------------------------------------------------------------------------- |
1118 } |
1095 // |
1119 iOtgStateObservers.AppendL(&aObserver); |
1096 void CUsbOtgWatcher::UnsubscribeL(MUsbOtgWatcherStateObserver* aObserver) |
1120 |
|
1121 } |
|
1122 |
|
1123 // --------------------------------------------------------------------------- |
|
1124 // |
|
1125 // --------------------------------------------------------------------------- |
|
1126 // |
|
1127 void CUsbOtgWatcher::UnsubscribeL(MUsbOtgWatcherStateObserver& aObserver) |
1097 { |
1128 { |
1098 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL" ) ); |
1129 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL" ) ); |
1099 if (0 == iOtgStateObservers.Count()) // no items |
1130 TInt i(iOtgStateObservers.Find(&aObserver)); |
1100 { |
1131 if(KErrNotFound == i) |
1101 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL No observers" ) ); |
1132 { |
1102 return; |
1133 FLOG( _L( "[USBOTGWATCHER]\tCUsbIdPinObserver::UnsubscribeL Observer not found." ) ); |
1103 } |
1134 Panic(ECanNotFindUsbOtgWatcherStateObserver); |
1104 |
1135 return; |
1105 TInt i(0); |
1136 } |
1106 while (i < iOtgStateObservers.Count() && aObserver != iOtgStateObservers[i]) |
1137 |
1107 ++i; |
|
1108 |
|
1109 if (aObserver == iOtgStateObservers[i]) // found |
|
1110 { |
|
1111 iOtgStateObservers.Remove(i); |
1138 iOtgStateObservers.Remove(i); |
1112 } |
1139 } |
1113 else |
|
1114 { |
|
1115 FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::UnsubscribeL CanNotGetUsbOtgStateWatcherObserver" ) ); |
|
1116 Panic(ECanNotFindUsbOtgWatcherStateObserver); |
|
1117 } |
|
1118 } |
|