17 |
17 |
18 |
18 |
19 |
19 |
20 // INCLUDE FILES |
20 // INCLUDE FILES |
21 #include <pathinfo.h> |
21 #include <pathinfo.h> |
|
22 #include <driveinfo.h> |
|
23 #include <usbwatcherinternalpskeys.h> |
|
24 #include <usbpersonalityids.h> |
22 |
25 |
23 #include "CamDriveChangeNotifier.h" |
26 #include "CamDriveChangeNotifier.h" |
24 #include "camlogging.h" |
27 #include "camlogging.h" |
25 #include "CamUtility.h" |
28 #include "CamUtility.h" |
26 |
29 |
|
30 |
|
31 _LIT(KDriveE, "E:\\"); |
|
32 _LIT(KDriveF, "F:\\"); |
27 |
33 |
28 // ============================ MEMBER FUNCTIONS =============================== |
34 // ============================ MEMBER FUNCTIONS =============================== |
29 |
35 |
30 // ----------------------------------------------------------------------------- |
36 // ----------------------------------------------------------------------------- |
31 // CCamDriveChangeNotifier::CCamDiskChangeListener::NewL |
37 // CCamDriveChangeNotifier::CCamDiskChangeListener::NewL |
33 // |
39 // |
34 CCamDriveChangeNotifier::CCamDiskChangeListener* |
40 CCamDriveChangeNotifier::CCamDiskChangeListener* |
35 CCamDriveChangeNotifier::CCamDiskChangeListener::NewLC( |
41 CCamDriveChangeNotifier::CCamDiskChangeListener::NewLC( |
36 RFs& aFs, |
42 RFs& aFs, |
37 TDriveNumber aDrive, |
43 TDriveNumber aDrive, |
38 MCamDriveChangeNotifierObserver::TCamDriveChangeType aType, |
|
39 CCamDriveChangeNotifier& aObserver ) |
44 CCamDriveChangeNotifier& aObserver ) |
40 { |
45 { |
41 PRINT( _L( "Camera => CCamDiskChangeListener::NewLC" ) ); |
46 PRINT( _L( "Camera => CCamDiskChangeListener::NewLC" ) ); |
42 |
47 |
43 CCamDiskChangeListener* self = |
48 CCamDiskChangeListener* self = |
44 new( ELeave ) CCamDiskChangeListener( aFs, aDrive, aType, aObserver ); |
49 new( ELeave ) CCamDiskChangeListener( aFs, aDrive, aObserver ); |
45 CleanupStack::PushL( self ); |
50 CleanupStack::PushL( self ); |
46 |
51 |
47 PRINT( _L( "Camera <= CCamDiskChangeListener::NewLC" ) ); |
52 PRINT( _L( "Camera <= CCamDiskChangeListener::NewLC" ) ); |
48 return self; |
53 return self; |
49 } |
54 } |
64 // ----------------------------------------------------------------------------- |
69 // ----------------------------------------------------------------------------- |
65 // |
70 // |
66 CCamDriveChangeNotifier::CCamDiskChangeListener::CCamDiskChangeListener( |
71 CCamDriveChangeNotifier::CCamDiskChangeListener::CCamDiskChangeListener( |
67 RFs& aFs, |
72 RFs& aFs, |
68 TDriveNumber aDrive, |
73 TDriveNumber aDrive, |
69 MCamDriveChangeNotifierObserver::TCamDriveChangeType aType, |
|
70 CCamDriveChangeNotifier& aObserver ) |
74 CCamDriveChangeNotifier& aObserver ) |
71 : CActive( CActive::EPriorityIdle ), |
75 : CActive( CActive::EPriorityIdle ), |
72 iFs( aFs ), |
76 iFs( aFs ), |
73 iDrive( aDrive ), |
77 iDrive( aDrive ), |
74 iType( aType ), |
|
75 iObserver( aObserver ) |
78 iObserver( aObserver ) |
76 { |
79 { |
77 CActiveScheduler::Add( this ); |
80 CActiveScheduler::Add( this ); |
78 } |
81 } |
79 |
82 |
87 if ( !IsActive() ) |
90 if ( !IsActive() ) |
88 { |
91 { |
89 PRINT( _L( "Camera <> CCamDiskChangeListener::Start SetActive()" ) ); |
92 PRINT( _L( "Camera <> CCamDiskChangeListener::Start SetActive()" ) ); |
90 |
93 |
91 // Start listening for change events |
94 // Start listening for change events |
92 iFs.NotifyChange( ENotifyDisk, iStatus ); |
95 if(iDrive == EDriveE) |
|
96 { |
|
97 iFs.NotifyChange( ENotifyDisk, iStatus, KDriveE ); |
|
98 } |
|
99 else if( iDrive == EDriveF ) |
|
100 { |
|
101 iFs.NotifyChange( ENotifyDisk, iStatus, KDriveF ); |
|
102 } |
|
103 else |
|
104 { |
|
105 iFs.NotifyChange( ENotifyDisk, iStatus ); |
|
106 } |
|
107 |
93 SetActive(); |
108 SetActive(); |
94 } |
109 } |
95 PRINT( _L( "Camera <= CCamDiskChangeListener::Start" ) ); |
110 PRINT( _L( "Camera <= CCamDiskChangeListener::Start" ) ); |
96 } |
111 } |
97 |
112 |
121 // CCamDriveChangeNotifier::CCamDiskChangeListener::RunL |
136 // CCamDriveChangeNotifier::CCamDiskChangeListener::RunL |
122 // ----------------------------------------------------------------------------- |
137 // ----------------------------------------------------------------------------- |
123 // |
138 // |
124 void CCamDriveChangeNotifier::CCamDiskChangeListener::RunL() |
139 void CCamDriveChangeNotifier::CCamDiskChangeListener::RunL() |
125 { |
140 { |
126 PRINT2( _L( "Camera => CCamDiskChangeListener::RunL iType: %d, iStatus: %d" ), iType, iStatus.Int() ); |
141 PRINT1( _L( "Camera => CCamDiskChangeListener::RunL, iStatus: %d" ), iStatus.Int() ); |
127 TInt ret = KErrNone; |
142 TInt ret = KErrNone; |
128 |
143 |
129 if ( iStatus == KErrNone ) |
144 if ( iStatus == KErrNone ) |
130 { |
145 { |
131 ret = iObserver.NotifyChangeL( iType ); |
146 TUint driveStatus; |
132 |
147 ret = DriveInfo::GetDriveStatus(iFs, iDrive, driveStatus ); |
|
148 |
|
149 if( ret == KErrNone) |
|
150 { |
|
151 if( !( driveStatus & DriveInfo::EDrivePresent ) || |
|
152 ( ( driveStatus & DriveInfo::EDrivePresent == DriveInfo::EDrivePresent ) && |
|
153 ( driveStatus & DriveInfo::EDriveInUse == DriveInfo::EDriveInUse ) ) ) |
|
154 { |
|
155 RDebug::Print(_L("CCamDiskChangeListener::RunL Dismount:%d"),iDrive); |
|
156 ret = iObserver.NotifyChangeL( MCamDriveChangeNotifierObserver::EDriveDismount ); |
|
157 } |
|
158 else if( ( driveStatus & DriveInfo::EDrivePresent ) == DriveInfo::EDrivePresent ) |
|
159 { |
|
160 RDebug::Print(_L("CCamDiskChangeListener::RunL Mount:%d"),iDrive); |
|
161 ret = iObserver.NotifyChangeL( MCamDriveChangeNotifierObserver::EDriveMount ); |
|
162 } |
|
163 } |
|
164 |
133 if( ret == KErrNone ) |
165 if( ret == KErrNone ) |
134 { |
166 { |
135 Start(); |
167 Start(); |
136 } |
168 } |
137 } |
169 } |
143 } |
175 } |
144 |
176 |
145 PRINT( _L( "Camera <= CCamDiskChangeListener::RunL" ) ); |
177 PRINT( _L( "Camera <= CCamDiskChangeListener::RunL" ) ); |
146 } |
178 } |
147 |
179 |
|
180 |
148 // ----------------------------------------------------------------------------- |
181 // ----------------------------------------------------------------------------- |
149 // CCamDriveChangeNotifier::CCamDriveChangeNotifier |
182 // CCamDriveChangeNotifier::CCamDriveChangeNotifier |
150 // ----------------------------------------------------------------------------- |
183 // ----------------------------------------------------------------------------- |
151 // |
184 // |
152 CCamDriveChangeNotifier::CCamDriveChangeNotifier( |
185 CCamDriveChangeNotifier::CCamDriveChangeNotifier( |
168 PRINT( _L( "Camera => CCamDriveChangeNotifier::NewL" ) ); |
201 PRINT( _L( "Camera => CCamDriveChangeNotifier::NewL" ) ); |
169 |
202 |
170 CCamDriveChangeNotifier* self = |
203 CCamDriveChangeNotifier* self = |
171 new( ELeave ) CCamDriveChangeNotifier( aFs, aObserver ); |
204 new( ELeave ) CCamDriveChangeNotifier( aFs, aObserver ); |
172 |
205 |
173 self->iListeners.AppendL( CCamDiskChangeListener::NewLC( self->iFs, EDriveE, |
206 self->ConstructL(); |
174 MCamDriveChangeNotifierObserver::EDriveMount, *self ) ); |
207 |
175 |
|
176 self->iListeners.AppendL( CCamDiskChangeListener::NewLC( self->iFs, EDriveD, |
|
177 MCamDriveChangeNotifierObserver::EDriveMount, *self ) ); |
|
178 |
|
179 CleanupStack::Pop(); // listener |
|
180 CleanupStack::Pop(); // listener 2 |
|
181 |
|
182 self->StartMonitoring(); |
|
183 |
|
184 PRINT( _L( "Camera <= CCamDriveChangeNotifier::NewL" ) ); |
208 PRINT( _L( "Camera <= CCamDriveChangeNotifier::NewL" ) ); |
185 return self; |
209 return self; |
186 } |
210 } |
187 |
211 |
188 |
212 |
190 CCamDriveChangeNotifier::~CCamDriveChangeNotifier() |
214 CCamDriveChangeNotifier::~CCamDriveChangeNotifier() |
191 { |
215 { |
192 PRINT( _L( "Camera => CCamDriveChangeNotifier::~CCamDriveChangeNotifier" ) ); |
216 PRINT( _L( "Camera => CCamDriveChangeNotifier::~CCamDriveChangeNotifier" ) ); |
193 CancelMonitoring(); |
217 CancelMonitoring(); |
194 iListeners.ResetAndDestroy(); |
218 iListeners.ResetAndDestroy(); |
|
219 if( iUsbMSWatcher ) |
|
220 { |
|
221 if( iUsbMSWatcher->IsActive() ) |
|
222 { |
|
223 iUsbMSWatcher->Cancel(); |
|
224 } |
|
225 delete iUsbMSWatcher; |
|
226 iUsbMSWatcher = NULL; |
|
227 } |
195 PRINT( _L( "Camera <= CCamDriveChangeNotifier::~CCamDriveChangeNotifier" ) ); |
228 PRINT( _L( "Camera <= CCamDriveChangeNotifier::~CCamDriveChangeNotifier" ) ); |
196 } |
229 } |
197 |
230 |
198 // ----------------------------------------------------------------------------- |
231 // ----------------------------------------------------------------------------- |
199 // CCamDriveChangeNotifier::StartMonitoring |
232 // CCamDriveChangeNotifier::StartMonitoring |
205 |
238 |
206 for ( TInt i = iListeners.Count(); --i >= 0; ) |
239 for ( TInt i = iListeners.Count(); --i >= 0; ) |
207 { |
240 { |
208 iListeners[i]->Start(); |
241 iListeners[i]->Start(); |
209 } |
242 } |
210 |
243 |
|
244 iUsbMSWatcher->Subscribe(); |
|
245 |
211 PRINT( _L( "Camera <= CCamDriveChangeNotifier::StartMonitoring" ) ); |
246 PRINT( _L( "Camera <= CCamDriveChangeNotifier::StartMonitoring" ) ); |
212 } |
247 } |
213 |
248 |
214 // ----------------------------------------------------------------------------- |
249 // ----------------------------------------------------------------------------- |
215 // CCamDriveChangeNotifier::CancelMonitoring |
250 // CCamDriveChangeNotifier::CancelMonitoring |
221 |
256 |
222 for ( TInt i = iListeners.Count(); --i >= 0; ) |
257 for ( TInt i = iListeners.Count(); --i >= 0; ) |
223 { |
258 { |
224 iListeners[i]->Stop(); |
259 iListeners[i]->Stop(); |
225 } |
260 } |
226 |
261 //iUsbMSWatcher->Cancel(); |
227 PRINT( _L( "Camera <= CCamDriveChangeNotifier::CancelMonitoring" ) ); |
262 PRINT( _L( "Camera <= CCamDriveChangeNotifier::CancelMonitoring" ) ); |
228 } |
263 } |
229 |
264 |
230 // ----------------------------------------------------------------------------- |
265 // ----------------------------------------------------------------------------- |
231 // CCamDriveChangeNotifier::NotifyChangeL |
266 // CCamDriveChangeNotifier::NotifyChangeL |
240 MCamDriveChangeNotifierObserver::EDriveDismount ) |
275 MCamDriveChangeNotifierObserver::EDriveDismount ) |
241 { |
276 { |
242 PRINT( _L("Camera <> iFs.AllowDismount( EDriveE )") ) |
277 PRINT( _L("Camera <> iFs.AllowDismount( EDriveE )") ) |
243 iFs.AllowDismount( EDriveE ); |
278 iFs.AllowDismount( EDriveE ); |
244 PRINT( _L("Camera <> iFs.AllowDismount( EDriveD )") ) |
279 PRINT( _L("Camera <> iFs.AllowDismount( EDriveD )") ) |
245 iFs.AllowDismount( EDriveD ); |
280 iFs.AllowDismount( EDriveF ); |
246 } |
281 } |
247 |
282 |
248 PRINT( _L( "Camera <= CCamDriveChangeNotifier::NotifyChangeL" ) ); |
283 PRINT( _L( "Camera <= CCamDriveChangeNotifier::NotifyChangeL" ) ); |
249 return ret; |
284 return ret; |
250 } |
285 } |
255 // |
290 // |
256 void CCamDriveChangeNotifier::SendAllowDismount() |
291 void CCamDriveChangeNotifier::SendAllowDismount() |
257 { |
292 { |
258 PRINT( _L( "Camera => CCamDriveChangeNotifier::SendAllowDismount" ) ); |
293 PRINT( _L( "Camera => CCamDriveChangeNotifier::SendAllowDismount" ) ); |
259 iFs.AllowDismount( EDriveE ); |
294 iFs.AllowDismount( EDriveE ); |
260 iFs.AllowDismount( EDriveD ); |
295 iFs.AllowDismount( EDriveF ); |
261 StartMonitoring(); |
296 StartMonitoring(); |
262 PRINT( _L( "Camera <= CCamDriveChangeNotifier::SendAllowDismount" ) ); |
297 PRINT( _L( "Camera <= CCamDriveChangeNotifier::SendAllowDismount" ) ); |
263 } |
298 } |
|
299 |
|
300 // ----------------------------------------------------------------------------- |
|
301 // CCamDriveChangeNotifier::HandlePropertyChangedL |
|
302 // ----------------------------------------------------------------------------- |
|
303 // |
|
304 void CCamDriveChangeNotifier::HandlePropertyChangedL( const TUid& aCategory, const TUint aKey ) |
|
305 { |
|
306 PRINT( _L( "Camera => CCamDriveChangeNotifier::HandlePropertyChangedL" ) ); |
|
307 TInt value = 0; |
|
308 if(KPSUidUsbWatcher == aCategory && |
|
309 KUsbWatcherSelectedPersonality == aKey) |
|
310 { |
|
311 iUsbMSWatcher->Get( value ); |
|
312 if( KUsbPersonalityIdMS == value ) |
|
313 { |
|
314 iMassStorageModeOn = ETrue; |
|
315 iObserver.DriveChangeL( MCamDriveChangeNotifierObserver::EDriveUSBMassStorageModeOn ); |
|
316 } |
|
317 else |
|
318 { |
|
319 if( iMassStorageModeOn ) |
|
320 { |
|
321 iMassStorageModeOn = EFalse; |
|
322 iObserver.DriveChangeL( MCamDriveChangeNotifierObserver::EDriveUSBMassStorageModeOff ); |
|
323 } |
|
324 } |
|
325 } |
|
326 |
|
327 PRINT( _L( "Camera <= CCamDriveChangeNotifier::HandlePropertyChangedL" ) ); |
|
328 } |
|
329 |
|
330 // ----------------------------------------------------------------------------- |
|
331 // CCamDriveChangeNotifier::ConstructL |
|
332 // ----------------------------------------------------------------------------- |
|
333 // |
|
334 void CCamDriveChangeNotifier::ConstructL() |
|
335 { |
|
336 |
|
337 iListeners.AppendL( CCamDiskChangeListener::NewLC( iFs, EDriveE, |
|
338 *this ) ); |
|
339 |
|
340 iListeners.AppendL( CCamDiskChangeListener::NewLC( iFs, EDriveF, |
|
341 *this ) ); |
|
342 |
|
343 iUsbMSWatcher = CCamPropertyWatcher::NewL(*this, KPSUidUsbWatcher, |
|
344 KUsbWatcherSelectedPersonality ); |
|
345 |
|
346 CleanupStack::Pop(); // listener |
|
347 CleanupStack::Pop(); // listener 2 |
|
348 |
|
349 StartMonitoring(); |
|
350 |
|
351 } |
264 // End of File |
352 // End of File |