9 // Nokia Corporation - initial contribution. |
9 // Nokia Corporation - initial contribution. |
10 // |
10 // |
11 // Contributors: |
11 // Contributors: |
12 // |
12 // |
13 // Description: |
13 // Description: |
14 // Class implementation of the drive publishing classes - |
14 // Class implementation of the drive publishing classes - |
15 // RDriveMediaErrorPublisher, |
15 // RDriveMediaErrorPublisher, |
16 // RDriveStateChangedPublisher, |
16 // RDriveStateChangedPublisher, |
17 // CDriveTransferPublisher, |
17 // CDriveTransferPublisher, |
18 // CDriveWriteTransferPublisher, |
18 // CDriveWriteTransferPublisher, |
19 // CDriveReadTransferPublisher, |
19 // CDriveReadTransferPublisher, |
20 // CUsbTransferPublisher, |
20 // CUsbTransferPublisher, |
21 // CUsbReadTransferPublisher, |
21 // CUsbReadTransferPublisher, |
22 // CUsbReadTransferPublisher. |
22 // CUsbReadTransferPublisher. |
23 // |
23 // |
24 // |
24 // |
25 |
25 |
26 /** |
26 /** |
27 @file |
27 @file |
28 @internalTechnology |
28 @internalTechnology |
29 */ |
29 */ |
30 |
30 |
31 #include "massstoragedebug.h" |
31 |
32 #include "drivepublisher.h" |
32 #include "drivepublisher.h" |
33 #include "drivemanager.h" |
33 #include "drivemanager.h" |
34 |
34 |
35 |
35 #include "OstTraceDefinitions.h" |
36 // |
36 #ifdef OST_TRACE_COMPILER_IN_USE |
|
37 #include "drivepublisherTraces.h" |
|
38 #endif |
|
39 |
|
40 |
|
41 |
|
42 // |
37 // Use Lookup table to translate from the internal pair of state variables |
43 // Use Lookup table to translate from the internal pair of state variables |
38 // to the externally published drive state code. |
44 // to the externally published drive state code. |
39 // |
45 // |
40 LOCAL_D const TUint8 table[][5] = |
46 static const TUint8 table[][5] = |
41 { |
47 { |
42 //TMountState=EDisconnected |
48 //TMountState=EDisconnected |
43 {EUsbMsDriveState_Disconnected, |
49 {EUsbMsDriveState_Disconnected, |
44 EUsbMsDriveState_Disconnected, |
50 EUsbMsDriveState_Disconnected, |
45 EUsbMsDriveState_Disconnected, |
51 EUsbMsDriveState_Disconnected, |
46 EUsbMsDriveState_Disconnected, |
52 EUsbMsDriveState_Disconnected, |
47 EUsbMsDriveState_Disconnected}, |
53 EUsbMsDriveState_Disconnected}, |
48 //TMountState=EConnecting |
54 //TMountState=EConnecting |
49 {EUsbMsDriveState_Connecting, |
55 {EUsbMsDriveState_Connecting, |
50 EUsbMsDriveState_Connecting, |
56 EUsbMsDriveState_Connecting, |
51 EUsbMsDriveState_Connecting, |
57 EUsbMsDriveState_Connecting, |
52 EUsbMsDriveState_Connecting, |
58 EUsbMsDriveState_Connecting, |
53 EUsbMsDriveState_Connecting}, |
59 EUsbMsDriveState_Connecting}, |
54 //TMountState=EConnected |
60 //TMountState=EConnected |
55 //EIdle,EActive,ELocked,EMediaNotPresent,EErrDisMounted |
61 //EIdle,EActive,ELocked,EMediaNotPresent,EErrDisMounted |
56 {EUsbMsDriveState_Connected, |
62 {EUsbMsDriveState_Connected, |
57 EUsbMsDriveState_Active, |
63 EUsbMsDriveState_Active, |
58 EUsbMsDriveState_Locked, |
64 EUsbMsDriveState_Locked, |
59 EUsbMsDriveState_MediaNotPresent, |
65 EUsbMsDriveState_MediaNotPresent, |
60 EUsbMsDriveState_Removed}, |
66 EUsbMsDriveState_Removed}, |
61 //TMountState=EDisconnecting |
67 //TMountState=EDisconnecting |
62 {EUsbMsDriveState_Disconnecting, |
68 {EUsbMsDriveState_Disconnecting, |
63 EUsbMsDriveState_Disconnecting, |
69 EUsbMsDriveState_Disconnecting, |
64 EUsbMsDriveState_Disconnecting, |
70 EUsbMsDriveState_Disconnecting, |
65 EUsbMsDriveState_Disconnecting, |
71 EUsbMsDriveState_Disconnecting, |
66 EUsbMsDriveState_Disconnecting} |
72 EUsbMsDriveState_Disconnecting} |
67 }; |
73 }; |
68 |
74 |
69 |
75 |
70 //---------------------------------------------------------------------------- |
76 //---------------------------------------------------------------------------- |
71 /** |
77 /** |
72 Constructor |
78 Constructor |
73 */ |
79 */ |
74 RDriveMediaErrorPublisher::RDriveMediaErrorPublisher() |
80 RDriveMediaErrorPublisher::RDriveMediaErrorPublisher() |
75 { |
81 { |
76 __FNLOG("RDriveMediaErrorPublisher::RDriveMediaErrorPublisher()"); |
82 _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy); |
77 |
83 _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid); |
78 _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy); |
84 |
79 _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid); |
85 TInt result = RProperty::Define(EUsbMsDriveState_MediaError, RProperty::EInt, |
80 |
86 KMassStorageReadPolicy, KMassStorageWritePolicy); |
81 TInt result = RProperty::Define(EUsbMsDriveState_MediaError, RProperty::EInt, |
87 |
82 KMassStorageReadPolicy, KMassStorageWritePolicy); |
88 __ASSERT_DEBUG(result == KErrAlreadyExists || result == KErrNone, User::Invariant()); |
83 |
89 |
84 __ASSERT_DEBUG(result == KErrAlreadyExists || result == KErrNone, User::Invariant()); |
90 result = iMediaErrorProperty.Attach(KUsbMsDriveState_Category, EUsbMsDriveState_MediaError); |
85 |
91 __ASSERT_DEBUG(result == KErrNone, User::Invariant()); |
86 result = iMediaErrorProperty.Attach(KUsbMsDriveState_Category, EUsbMsDriveState_MediaError); |
92 } |
87 __ASSERT_DEBUG(result == KErrNone, User::Invariant()); |
|
88 } |
|
89 |
93 |
90 |
94 |
91 RDriveMediaErrorPublisher::~RDriveMediaErrorPublisher() |
95 RDriveMediaErrorPublisher::~RDriveMediaErrorPublisher() |
92 { |
96 { |
93 __FNLOG("RDriveStatePublisher::~RDriveStatePublisher()"); |
97 iMediaErrorProperty.Close(); |
94 |
98 RProperty::Delete(KUsbMsDriveState_Category, EUsbMsDriveState_MediaError); |
95 iMediaErrorProperty.Close(); |
99 } |
96 RProperty::Delete(KUsbMsDriveState_Category, EUsbMsDriveState_MediaError); |
|
97 } |
|
98 |
100 |
99 /** |
101 /** |
100 Publishing method |
102 Publishing method |
101 |
103 |
102 Publishes the Media Error property event |
104 Publishes the Media Error property event |
103 |
105 |
104 @param aError ETrue if drive media has an error else EFalse for no error |
106 @param aError ETrue if drive media has an error else EFalse for no error |
105 */ |
107 */ |
106 void RDriveMediaErrorPublisher::PublishError(TBool aError) |
108 void RDriveMediaErrorPublisher::PublishError(TBool aError) |
107 { |
109 { |
108 __PRINT1(_L("<< RDriveMediaErrorPublisher::PublishError %x"), aError); |
110 OstTraceFunctionEntry0(DRIVEPUBLISHER_100); |
109 |
111 TInt oldValue; |
110 TInt oldValue; |
112 iMediaErrorProperty.Get(oldValue); |
111 iMediaErrorProperty.Get(oldValue); |
113 |
112 |
114 if (oldValue != aError) |
113 if (oldValue != aError) |
115 { |
114 { |
116 User::LeaveIfError(iMediaErrorProperty.Set(aError)); |
115 User::LeaveIfError(iMediaErrorProperty.Set(aError)); |
117 } |
116 } |
118 } |
117 } |
|
118 |
119 |
119 //---------------------------------------------------------------------------- |
120 //---------------------------------------------------------------------------- |
120 /** |
121 /** |
121 Constructor |
122 Constructor |
122 |
123 |
123 @param aDrives |
124 @param aDrives |
124 @param aDriveMap |
125 @param aDriveMap |
125 */ |
126 */ |
126 RDriveStateChangedPublisher::RDriveStateChangedPublisher(TRefMsDriveList aDrives, |
127 RDriveStateChangedPublisher::RDriveStateChangedPublisher(TRefMsDriveList aDrives, |
127 TRefDriveMap aDriveMap) |
128 TRefDriveMap aDriveMap) |
128 : |
129 : |
129 iDrives(aDrives), |
130 iDrives(aDrives), |
130 iDriveMap(aDriveMap) |
131 iDriveMap(aDriveMap) |
131 { |
132 { |
132 __FNLOG("RDriveStateChangedPublisher::RDriveStateChangedPublisher()"); |
133 _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy); |
133 |
134 _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid); |
134 _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy); |
135 |
135 _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid); |
136 TInt result = RProperty::Define(KUsbMsDriveState_Category, |
136 |
137 EUsbMsDriveState_DriveStatus, RProperty::EByteArray, |
137 TInt result = RProperty::Define(KUsbMsDriveState_Category, |
138 KMassStorageReadPolicy, KMassStorageWritePolicy, |
138 EUsbMsDriveState_DriveStatus, RProperty::EByteArray, |
139 KUsbMsMaxDrives*2); |
139 KMassStorageReadPolicy, KMassStorageWritePolicy, |
140 __ASSERT_DEBUG(result == KErrAlreadyExists || result == KErrNone, User::Invariant()); |
140 KUsbMsMaxDrives*2); |
141 result = result; // remove urel warning |
141 __ASSERT_DEBUG(result == KErrAlreadyExists || result == KErrNone, User::Invariant()); |
142 } |
142 result = result; // remove urel warning |
|
143 } |
|
144 |
143 |
145 |
144 |
146 RDriveStateChangedPublisher::~RDriveStateChangedPublisher() |
145 RDriveStateChangedPublisher::~RDriveStateChangedPublisher() |
147 { |
146 { |
148 __FNLOG("RDriveStateChangedPublisher::~RDriveStateChangedPublisher()"); |
147 RProperty::Delete(KUsbMsDriveState_Category, EUsbMsDriveState_DriveStatus); |
149 |
148 } |
150 RProperty::Delete(KUsbMsDriveState_Category, EUsbMsDriveState_DriveStatus); |
|
151 } |
|
152 |
149 |
153 |
150 |
154 /** |
151 /** |
155 Publishing method |
152 Publishing method |
156 |
153 |
157 Sends a property event on behalf of CMassStorageDrive, with the mountstate and drivestate |
154 Sends a property event on behalf of CMassStorageDrive, with the mountstate and drivestate |
158 values encoded into one 32-bit word. |
155 values encoded into one 32-bit word. |
159 */ |
156 */ |
160 void RDriveStateChangedPublisher::DriveStateChanged() |
157 void RDriveStateChangedPublisher::DriveStateChanged() |
161 { |
158 { |
162 __FNLOG("RDriveStateChangedPublisher::DriveStateChanged"); |
159 TUsbMsDrivesStatus allDrivesStatus; |
163 |
160 for(TUint8 i=0; i<KUsbMsMaxDrives && iDrives[i]; i++) |
164 |
161 { |
165 TUsbMsDrivesStatus allDrivesStatus; |
162 allDrivesStatus.Append(iDriveMap[i]); |
166 for(TUint8 i=0; i<KUsbMsMaxDrives && iDrives[i]; i++) |
163 |
167 { |
164 CMassStorageDrive::TMountState ms = iDrives[i]->MountState(); |
168 allDrivesStatus.Append(iDriveMap[i]); |
165 CMassStorageDrive::TDriveState ds = iDrives[i]->DriveState(); |
169 |
166 TInt driveStatus = EUsbMsDriveState_Error; |
170 CMassStorageDrive::TMountState ms = iDrives[i]->MountState(); |
167 if((TUint8)ds < sizeof(table[0]) && (TUint8)ms < sizeof(table)/sizeof(table[0])) |
171 CMassStorageDrive::TDriveState ds = iDrives[i]->DriveState(); |
168 { |
172 TInt driveStatus = EUsbMsDriveState_Error; |
169 driveStatus = table[ms][ds]; |
173 if((TUint8)ds < sizeof(table[0]) && (TUint8)ms < sizeof(table)/sizeof(table[0])) |
170 OstTraceExt3(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_110, |
174 { |
171 "ms=%d ds=%d %d", ms, ds, driveStatus); |
175 driveStatus = table[ms][ds]; |
172 } |
176 __PRINT3(_L("ms=%d ds=%d %d"), ms, ds, driveStatus); |
173 allDrivesStatus.Append(driveStatus); |
177 } |
174 } |
178 allDrivesStatus.Append(driveStatus); |
175 |
179 } |
176 OstTrace1(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_111, |
180 |
177 "Publishing EUsbMsDriveState_DriveStatus for %d drives", allDrivesStatus.Length()/2); |
181 __PRINT1(_L("Publishing EUsbMsDriveState_DriveStatus for %d drives\n"), |
178 |
182 allDrivesStatus.Length()/2); |
179 if(KErrNone != RProperty::Set(KUsbMsDriveState_Category, |
183 |
180 EUsbMsDriveState_DriveStatus, |
184 if(KErrNone != RProperty::Set(KUsbMsDriveState_Category, |
181 allDrivesStatus)) |
185 EUsbMsDriveState_DriveStatus, |
182 { |
186 allDrivesStatus)) |
183 __ASSERT_DEBUG(EFalse,User::Invariant()); |
187 { |
184 } |
188 __ASSERT_DEBUG(EFalse,User::Invariant()); |
185 } |
189 } |
|
190 } |
|
191 |
186 |
192 |
187 |
193 //---------------------------------------------------------------------------- |
188 //---------------------------------------------------------------------------- |
194 #ifndef USB_TRANSFER_PUBLISHER |
189 #ifndef USB_TRANSFER_PUBLISHER |
195 /** |
190 /** |
196 Private default constructor to ensure that NewL is used |
191 Private default constructor to ensure that NewL is used |
197 |
192 |
198 @param aSubKey |
193 @param aSubKey |
199 @param aDrives |
194 @param aDrives |
200 */ |
195 */ |
201 CDriveTransferPublisher::CDriveTransferPublisher( |
196 CDriveTransferPublisher::CDriveTransferPublisher( |
202 TUsbMsDriveState_Subkey aSubKey, |
197 TUsbMsDriveState_Subkey aSubKey, |
203 TRefMsDriveList aDrives) |
198 TRefMsDriveList aDrives) |
204 : |
199 : |
205 iSubKey(aSubKey), |
200 iSubKey(aSubKey), |
206 iDrives(aDrives) |
201 iDrives(aDrives) |
207 { |
202 { |
208 } |
203 } |
209 |
204 |
210 |
205 |
211 void CDriveTransferPublisher::ConstructL() |
206 void CDriveTransferPublisher::ConstructL() |
212 { |
207 { |
213 __FNLOG("CDriveTransferPublisher::ConstructL"); |
208 _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy); |
214 |
209 _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid); |
215 _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy); |
210 |
216 _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid); |
211 TInt r = RProperty::Define(iSubKey, RProperty::EByteArray, |
217 |
212 KMassStorageReadPolicy, KMassStorageWritePolicy, |
218 TInt r = RProperty::Define(iSubKey, RProperty::EByteArray, |
213 KUsbMsMaxDrives*sizeof(TInt)); |
219 KMassStorageReadPolicy, KMassStorageWritePolicy, |
214 |
220 KUsbMsMaxDrives*sizeof(TInt)); |
215 if (r != KErrAlreadyExists) |
221 |
216 { |
222 if (r != KErrAlreadyExists) |
217 User::LeaveIfError(r); |
223 { |
218 } |
224 User::LeaveIfError(r); |
219 |
225 } |
220 User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, iSubKey)); |
226 |
221 |
227 User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, iSubKey)); |
222 // Create the EDataTransferred timer |
228 |
223 iTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
229 // Create the EDataTransferred timer |
224 iTimerRunning = EFalse; |
230 iTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
225 } |
231 iTimerRunning = EFalse; |
|
232 } |
|
233 |
226 |
234 |
227 |
235 /** |
228 /** |
236 Destructor |
229 Destructor |
237 */ |
230 */ |
238 CDriveTransferPublisher::~CDriveTransferPublisher() |
231 CDriveTransferPublisher::~CDriveTransferPublisher() |
239 { |
232 { |
240 __FNLOG("CDriveTransferPublisher::~CDriveTransferPublisher"); |
233 if(iTimer) |
241 |
234 { |
242 if(iTimer) |
235 iTimer->Cancel(); |
243 { |
236 } |
244 iTimer->Cancel(); |
237 delete iTimer; |
245 } |
238 |
246 delete iTimer; |
239 iProperty.Close(); |
247 |
240 |
248 iProperty.Close(); |
241 RProperty::Delete(KUsbMsDriveState_Category, iSubKey); |
249 |
242 } |
250 RProperty::Delete(KUsbMsDriveState_Category, iSubKey); |
|
251 } |
|
252 |
243 |
253 |
244 |
254 /** |
245 /** |
255 A static wrapper for the DoPublishDataTransferredEvent member function |
246 A static wrapper for the DoPublishDataTransferredEvent member function |
256 for use as a timer callback function. |
247 for use as a timer callback function. |
257 |
248 |
258 @param obj 'this' pointer |
249 @param obj 'this' pointer |
259 @return not used in CPeriodic callback (see TCallback) |
250 @return not used in CPeriodic callback (see TCallback) |
260 */ |
251 */ |
261 TInt CDriveTransferPublisher::PublishDataTransferredEvent(TAny* obj) |
252 TInt CDriveTransferPublisher::PublishDataTransferredEvent(TAny* obj) |
262 { |
253 { |
263 __FNLOG("CDrivePublisher::PublishDataTransferredEvent"); |
254 static_cast<CDriveTransferPublisher*>(obj)->DoPublishDataTransferredEvent(); |
264 static_cast<CDriveTransferPublisher*>(obj)->DoPublishDataTransferredEvent(); |
255 return 1; |
265 return 1; |
256 } |
266 } |
|
267 |
257 |
268 |
258 |
269 /** |
259 /** |
270 Update the data transferred properties if the counts have changed since |
260 Update the data transferred properties if the counts have changed since |
271 the last update. |
261 the last update. |
272 */ |
262 */ |
273 void CDriveTransferPublisher::DoPublishDataTransferredEvent() |
263 void CDriveTransferPublisher::DoPublishDataTransferredEvent() |
274 { |
264 { |
275 if (PublishDataTransferred()) |
265 if (PublishDataTransferred()) |
276 { |
266 { |
277 // some data has been transfered so reset the counter |
267 // some data has been transfered so reset the counter |
278 iTimerCancelCnt = ETimerCancelDelay; |
268 iTimerCancelCnt = ETimerCancelDelay; |
279 } |
269 } |
280 |
270 |
281 // Update the cancel count if no data was transferred the last |
271 // Update the cancel count if no data was transferred the last |
282 // (few) times this has been called |
272 // (few) times this has been called |
283 if (--iTimerCancelCnt == 0) |
273 if (--iTimerCancelCnt == 0) |
284 { |
274 { |
285 StopTimer(); |
275 StopTimer(); |
286 iTimerCancelCnt = ETimerCancelDelay; |
276 iTimerCancelCnt = ETimerCancelDelay; |
287 } |
277 } |
288 } |
278 } |
289 |
279 |
290 |
280 |
291 /** |
281 /** |
292 Update the data transferred properties if the counts have changed since |
282 Update the data transferred properties if the counts have changed since |
293 the last update. |
283 the last update. |
294 */ |
284 */ |
295 TBool CDriveTransferPublisher::PublishDataTransferred() |
285 TBool CDriveTransferPublisher::PublishDataTransferred() |
296 { |
286 { |
297 __FNLOG("CDriveWriteTransferPublisher::PublishDataTransferred"); |
287 TUsbMsBytesTransferred bytesTransferred; |
298 |
288 TBool dataTransferred = EFalse; |
299 TUsbMsBytesTransferred bytesTransferred; |
289 |
300 TBool dataTransferred = EFalse; |
290 for (TInt i=0; i < iDrives.Count() && iDrives[i]; i++) |
301 |
291 { |
302 for (TInt i=0; i < iDrives.Count() && iDrives[i]; i++) |
292 bytesTransferred[i] = GetBytesTransferred(i); |
303 { |
293 } |
304 bytesTransferred[i] = GetBytesTransferred(i); |
294 |
305 } |
295 // Update the properties only if they have changed |
306 |
296 // (or if there's an error reading the old value.) |
307 // Update the properties only if they have changed |
297 // Possible optimisation: keep a copy of the value |
308 // (or if there's an error reading the old value.) |
298 // as a member variable so we don't need the Get. |
309 // Possible optimisation: keep a copy of the value |
299 TUsbMsBytesTransferred oldValue; |
310 // as a member variable so we don't need the Get. |
300 |
311 TUsbMsBytesTransferred oldValue; |
301 if ((iProperty.Get(oldValue) != KErrNone) || (oldValue != bytesTransferred)) |
312 |
302 { |
313 if ((iProperty.Get(oldValue) != KErrNone) || (oldValue != bytesTransferred)) |
|
314 { |
|
315 #ifdef __PRINT3 |
303 #ifdef __PRINT3 |
316 for (TInt j=0; j < iDrives.Count() && iDrives[j]; j++) |
304 for (TInt j=0; j < iDrives.Count() && iDrives[j]; j++) |
317 { |
305 { |
318 if(oldValue[j] != bytesTransferred[j]) |
306 if(oldValue[j] != bytesTransferred[j]) |
319 { |
307 { |
320 __PRINT3(_L("CDrivePublisher: KBytes[%d] %d->%d\n"), j, oldValue[j], bytesTransferred[j]); |
308 __PRINT3(_L("CDrivePublisher: KBytes[%d] %d->%d\n"), j, oldValue[j], bytesTransferred[j]); |
321 } |
309 } |
322 } |
310 } |
323 #endif |
311 #endif |
324 if (KErrNone != iProperty.Set(bytesTransferred)) |
312 if (KErrNone != iProperty.Set(bytesTransferred)) |
325 { |
313 { |
326 __ASSERT_DEBUG(EFalse, User::Invariant()); |
314 __ASSERT_DEBUG(EFalse, User::Invariant()); |
327 } |
315 } |
328 dataTransferred = ETrue; |
316 dataTransferred = ETrue; |
329 } |
317 } |
330 |
318 |
331 return dataTransferred; |
319 return dataTransferred; |
332 } |
320 } |
333 |
321 |
334 |
322 |
335 /** |
323 /** |
336 Starts timer to periodically publish results. |
324 Starts timer to periodically publish results. |
337 If the timer is not yet running then start it. |
325 If the timer is not yet running then start it. |
338 */ |
326 */ |
339 void CDriveTransferPublisher::StartTimer() |
327 void CDriveTransferPublisher::StartTimer() |
340 { |
328 { |
341 __FNLOG("CDrivePublisher::StartTimer"); |
329 if (!iTimerRunning) |
342 |
330 { |
343 if (!iTimerRunning) |
331 // EDataTransferred event every second |
344 { |
332 const TTimeIntervalMicroSeconds32 interval = 1 * 1000 * 1000; |
345 // EDataTransferred event every second |
333 TCallBack callback(PublishDataTransferredEvent, this); |
346 const TTimeIntervalMicroSeconds32 interval = 1 * 1000 * 1000; |
334 OstTrace0(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_140, "Starting timer"); |
347 TCallBack callback(PublishDataTransferredEvent, this); |
335 iTimer->Start(interval, interval, callback); |
348 __PRINT(_L("Starting timer")); |
336 iTimerRunning = ETrue; |
349 iTimer->Start(interval, interval, callback); |
337 } |
350 iTimerRunning = ETrue; |
338 } |
351 } |
|
352 } |
|
353 |
339 |
354 |
340 |
355 /** |
341 /** |
356 Ensure that the Timer is stopped |
342 Ensure that the Timer is stopped |
357 */ |
343 */ |
358 void CDriveTransferPublisher::StopTimer() |
344 void CDriveTransferPublisher::StopTimer() |
359 { |
345 { |
360 __FNLOG("CDrivePublisher::StopTimer"); |
346 if (iTimerRunning) |
361 |
347 { |
362 if (iTimerRunning) |
348 OstTrace0(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_141, "Stopping timer"); |
363 { |
349 iTimer->Cancel(); |
364 __PRINT(_L("Stopping timer")); |
350 iTimerRunning = EFalse; |
365 iTimer->Cancel(); |
351 } |
366 iTimerRunning = EFalse; |
352 } |
367 } |
|
368 } |
|
369 |
353 |
370 |
354 |
371 //---------------------------------------------------------------------------- |
355 //---------------------------------------------------------------------------- |
372 /** |
356 /** |
373 Constructor for Write property |
357 Constructor for Write property |
374 |
358 |
375 @param aDrives |
359 @param aDrives |
376 */ |
360 */ |
377 CDriveWriteTransferPublisher* CDriveWriteTransferPublisher::NewL(TRefMsDriveList aDrives) |
361 CDriveWriteTransferPublisher* CDriveWriteTransferPublisher::NewL(TRefMsDriveList aDrives) |
378 { |
362 { |
379 __FNLOG("CDriveWriteTransferPublisher::NewL"); |
363 CDriveWriteTransferPublisher* self = new (ELeave) CDriveWriteTransferPublisher(aDrives); |
380 |
364 CleanupStack::PushL(self); |
381 CDriveWriteTransferPublisher* self = new (ELeave) CDriveWriteTransferPublisher(aDrives); |
365 self->ConstructL(); |
382 CleanupStack::PushL(self); |
366 CleanupStack::Pop(); |
383 self->ConstructL(); |
367 return self; |
384 CleanupStack::Pop(); |
368 } |
385 return self; |
|
386 } |
|
387 |
369 |
388 |
370 |
389 /** |
371 /** |
390 Constructor |
372 Constructor |
391 |
373 |
392 @param aDrives |
374 @param aDrives |
393 */ |
375 */ |
394 CDriveWriteTransferPublisher::CDriveWriteTransferPublisher(TRefMsDriveList aDrives) |
376 CDriveWriteTransferPublisher::CDriveWriteTransferPublisher(TRefMsDriveList aDrives) |
395 : |
377 : |
396 CDriveTransferPublisher(EUsbMsDriveState_KBytesWritten, aDrives) |
378 CDriveTransferPublisher(EUsbMsDriveState_KBytesWritten, aDrives) |
397 { |
379 { |
398 } |
380 } |
399 |
381 |
400 |
382 |
401 /** |
383 /** |
402 Transfer function for Write property |
384 Transfer function for Write property |
403 |
385 |
404 @param aLun |
386 @param aLun |
405 */ |
387 */ |
406 TUint CDriveWriteTransferPublisher::GetBytesTransferred(TUint aLun) const |
388 TUint CDriveWriteTransferPublisher::GetBytesTransferred(TUint aLun) const |
407 { |
389 { |
408 return iDrives[aLun]->KBytesWritten(); |
390 return iDrives[aLun]->KBytesWritten(); |
409 } |
391 } |
410 |
392 |
411 |
393 |
412 //---------------------------------------------------------------------------- |
394 //---------------------------------------------------------------------------- |
413 /** |
395 /** |
414 Constructor for Read property |
396 Constructor for Read property |
415 |
397 |
416 @param aDrives |
398 @param aDrives |
417 */ |
399 */ |
418 CDriveReadTransferPublisher* CDriveReadTransferPublisher::NewL(TRefMsDriveList aDrives) |
400 CDriveReadTransferPublisher* CDriveReadTransferPublisher::NewL(TRefMsDriveList aDrives) |
419 { |
401 { |
420 __FNLOG("CDriveWriteTransferPublisher::NewL"); |
402 CDriveReadTransferPublisher* self = new (ELeave) CDriveReadTransferPublisher(aDrives); |
421 |
403 CleanupStack::PushL(self); |
422 CDriveReadTransferPublisher* self = new (ELeave) CDriveReadTransferPublisher(aDrives); |
404 self->ConstructL(); |
423 CleanupStack::PushL(self); |
405 CleanupStack::Pop(); |
424 self->ConstructL(); |
406 return self; |
425 CleanupStack::Pop(); |
407 } |
426 return self; |
|
427 } |
|
428 |
408 |
429 |
409 |
430 /** |
410 /** |
431 Constructor |
411 Constructor |
432 |
412 |
433 @param aDrives |
413 @param aDrives |
434 */ |
414 */ |
435 CDriveReadTransferPublisher::CDriveReadTransferPublisher(TRefMsDriveList aDrives) |
415 CDriveReadTransferPublisher::CDriveReadTransferPublisher(TRefMsDriveList aDrives) |
436 : |
416 : |
437 CDriveTransferPublisher(EUsbMsDriveState_KBytesRead, aDrives) |
417 CDriveTransferPublisher(EUsbMsDriveState_KBytesRead, aDrives) |
438 { |
418 { |
439 } |
419 } |
440 |
420 |
441 |
421 |
442 /** |
422 /** |
443 Transfer function for Read property |
423 Transfer function for Read property |
444 |
424 |
445 @param aLun |
425 @param aLun |
446 */ |
426 */ |
447 TUint CDriveReadTransferPublisher::GetBytesTransferred(TUint aLun) const |
427 TUint CDriveReadTransferPublisher::GetBytesTransferred(TUint aLun) const |
448 { |
428 { |
449 return iDrives[aLun]->KBytesRead(); |
429 return iDrives[aLun]->KBytesRead(); |
450 } |
430 } |
451 |
431 |
452 |
432 |
453 //---------------------------------------------------------------------------- |
433 //---------------------------------------------------------------------------- |
454 #else |
434 #else |
455 /** |
435 /** |
456 Private default constructor to ensure that NewL is used |
436 Private default constructor to ensure that NewL is used |
457 |
437 |
458 @param aSubKey |
438 @param aSubKey |
459 @param aArray |
439 @param aArray |
460 */ |
440 */ |
461 CUsbTransferPublisher::CUsbTransferPublisher( |
441 CUsbTransferPublisher::CUsbTransferPublisher( |
462 TUsbMsDriveState_Subkey aSubKey, |
442 TUsbMsDriveState_Subkey aSubKey, |
463 TRefBytesTransferedList aArray) |
443 TRefBytesTransferedList aArray) |
464 : |
444 : |
465 iSubKey(aSubKey), |
445 iSubKey(aSubKey), |
466 iArray(aArray) |
446 iArray(aArray) |
467 { |
447 { |
468 } |
448 } |
469 |
449 |
470 |
450 |
471 void CUsbTransferPublisher::ConstructL() |
451 void CUsbTransferPublisher::ConstructL() |
472 { |
452 { |
473 __FNLOG("CUsbTransferPublisher::ConstructL"); |
453 _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy); |
474 |
454 _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid); |
475 _LIT_SECURITY_POLICY_PASS(KMassStorageReadPolicy); |
455 |
476 _LIT_SECURITY_POLICY_S0(KMassStorageWritePolicy, KUsbMsDriveState_Category.iUid); |
456 TInt r = RProperty::Define(iSubKey, RProperty::EByteArray, |
477 |
457 KMassStorageReadPolicy, KMassStorageWritePolicy, |
478 TInt r = RProperty::Define(iSubKey, RProperty::EByteArray, |
458 KUsbMsMaxDrives*sizeof(TInt)); |
479 KMassStorageReadPolicy, KMassStorageWritePolicy, |
459 |
480 KUsbMsMaxDrives*sizeof(TInt)); |
460 if (r != KErrAlreadyExists) |
481 |
461 { |
482 if (r != KErrAlreadyExists) |
462 User::LeaveIfError(r); |
483 { |
463 } |
484 User::LeaveIfError(r); |
464 |
485 } |
465 // Attach to the properties here. Only do this once, continuously attaching |
486 |
466 // will currently cause a memory leak |
487 // Attach to the properties here. Only do this once, continuously attaching |
467 User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, iSubKey)); |
488 // will currently cause a memory leak |
468 |
489 User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, iSubKey)); |
469 // Create the EDataTransferred timer |
490 |
470 iTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
491 // Create the EDataTransferred timer |
471 iTimerRunning = EFalse; |
492 iTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
472 } |
493 iTimerRunning = EFalse; |
|
494 } |
|
495 |
473 |
496 |
474 |
497 /** |
475 /** |
498 Destructor |
476 Destructor |
499 */ |
477 */ |
500 CUsbTransferPublisher::~CUsbTransferPublisher() |
478 CUsbTransferPublisher::~CUsbTransferPublisher() |
501 { |
479 { |
502 __FNLOG("CUsbTransferPublisher::~CDriveTransferPublisher"); |
480 if(iTimer) |
503 |
481 { |
504 if(iTimer) |
482 iTimer->Cancel(); |
505 { |
483 } |
506 iTimer->Cancel(); |
484 delete iTimer; |
507 } |
485 |
508 delete iTimer; |
486 iProperty.Close(); |
509 |
487 |
510 iProperty.Close(); |
488 RProperty::Delete(KUsbMsDriveState_Category, iSubKey); |
511 |
489 } |
512 RProperty::Delete(KUsbMsDriveState_Category, iSubKey); |
|
513 } |
|
514 |
490 |
515 |
491 |
516 /** |
492 /** |
517 A static wrapper for the DoPublishDataTransferredEvent member function |
493 A static wrapper for the DoPublishDataTransferredEvent member function |
518 for use as a timer callback function. |
494 for use as a timer callback function. |
519 |
495 |
520 @param obj 'this' pointer |
496 @param obj 'this' pointer |
521 @return not used in CPeriodic callback (see TCallback) |
497 @return not used in CPeriodic callback (see TCallback) |
522 */ |
498 */ |
523 TInt CUsbTransferPublisher::PublishDataTransferredEvent(TAny* obj) |
499 TInt CUsbTransferPublisher::PublishDataTransferredEvent(TAny* obj) |
524 { |
500 { |
525 __FNLOG("CUsbTransferPublisher::PublishDataTransferredEvent"); |
501 static_cast<CUsbTransferPublisher*>(obj)->DoPublishDataTransferredEvent(); |
526 static_cast<CUsbTransferPublisher*>(obj)->DoPublishDataTransferredEvent(); |
502 return 1; |
527 return 1; |
503 } |
528 } |
|
529 |
504 |
530 |
505 |
531 /** |
506 /** |
532 Update the data transferred properties if the counts have changed since |
507 Update the data transferred properties if the counts have changed since |
533 the last update. |
508 the last update. |
534 */ |
509 */ |
535 void CUsbTransferPublisher::DoPublishDataTransferredEvent() |
510 void CUsbTransferPublisher::DoPublishDataTransferredEvent() |
536 { |
511 { |
537 if (PublishDataTransferred()) |
512 if (PublishDataTransferred()) |
538 { |
513 { |
539 // some data has been transfered so reset the counter |
514 // some data has been transfered so reset the counter |
540 iTimerCancelCnt = ETimerCancelDelay; |
515 iTimerCancelCnt = ETimerCancelDelay; |
541 } |
516 } |
542 |
517 |
543 // Update the cancel count if no data was transferred the last |
518 // Update the cancel count if no data was transferred the last |
544 // (few) times this has been called |
519 // (few) times this has been called |
545 if (--iTimerCancelCnt == 0) |
520 if (--iTimerCancelCnt == 0) |
546 { |
521 { |
547 StopTimer(); |
522 StopTimer(); |
548 iTimerCancelCnt = ETimerCancelDelay; |
523 iTimerCancelCnt = ETimerCancelDelay; |
549 } |
524 } |
550 } |
525 } |
551 |
526 |
552 |
527 |
553 /** |
528 /** |
554 Update the data transferred properties if the counts have changed since |
529 Update the data transferred properties if the counts have changed since |
555 the last update. |
530 the last update. |
556 */ |
531 */ |
557 TBool CUsbTransferPublisher::PublishDataTransferred() |
532 TBool CUsbTransferPublisher::PublishDataTransferred() |
558 { |
533 { |
559 __FNLOG("CUsbWriteTransferPublisher::PublishDataTransferred"); |
534 TUsbMsBytesTransferred bytesTransferred; |
560 |
535 TBool dataTransferred = EFalse; |
561 TUsbMsBytesTransferred bytesTransferred; |
536 |
562 TBool dataTransferred = EFalse; |
537 for (TInt i = 0; i < iArray.Count(); i++) |
563 |
538 { |
564 for (TInt i = 0; i < iArray.Count(); i++) |
539 bytesTransferred[i] = GetBytesTransferred(i); |
565 { |
540 } |
566 bytesTransferred[i] = GetBytesTransferred(i); |
541 |
567 } |
542 // Update the properties only if they have changed |
568 |
543 // (or if there's an error reading the old value.) |
569 // Update the properties only if they have changed |
544 // Possible optimisation: keep a copy of the value |
570 // (or if there's an error reading the old value.) |
545 // as a member variable so we don't need the Get. |
571 // Possible optimisation: keep a copy of the value |
546 TUsbMsBytesTransferred oldValue; |
572 // as a member variable so we don't need the Get. |
547 |
573 TUsbMsBytesTransferred oldValue; |
548 if ((iProperty.Get(oldValue) != KErrNone) || (oldValue != bytesTransferred)) |
574 |
549 { |
575 if ((iProperty.Get(oldValue) != KErrNone) || (oldValue != bytesTransferred)) |
|
576 { |
|
577 #ifdef __PRINT3 |
550 #ifdef __PRINT3 |
578 // trace of the bytes transferred |
551 // trace of the bytes transferred |
579 for (TInt j=0; j < iArray.Count(); j++) |
552 for (TInt j=0; j < iArray.Count(); j++) |
580 { |
553 { |
581 if(oldValue[j] != bytesTransferred[j]) |
554 if(oldValue[j] != bytesTransferred[j]) |
582 { |
555 { |
583 __PRINT3(_L("CDrivePublisher: KBytes[%d] %d->%d\n"), j, oldValue[j], bytesTransferred[j]); |
556 __PRINT3(_L("CDrivePublisher: KBytes[%d] %d->%d\n"), j, oldValue[j], bytesTransferred[j]); |
584 } |
557 } |
585 } |
558 } |
586 #endif |
559 #endif |
587 if (KErrNone != iProperty.Set(bytesTransferred)) |
560 if (KErrNone != iProperty.Set(bytesTransferred)) |
588 { |
561 { |
589 __ASSERT_DEBUG(EFalse, User::Invariant()); |
562 __ASSERT_DEBUG(EFalse, User::Invariant()); |
590 } |
563 } |
591 dataTransferred = ETrue; |
564 dataTransferred = ETrue; |
592 } |
565 } |
593 |
566 |
594 return dataTransferred; |
567 return dataTransferred; |
595 } |
568 } |
596 |
569 |
597 |
570 |
598 /** |
571 /** |
599 Starts timer to periodically publish results. |
572 Starts timer to periodically publish results. |
600 If the timer is not yet running then start it. |
573 If the timer is not yet running then start it. |
601 */ |
574 */ |
602 void CUsbTransferPublisher::StartTimer() |
575 void CUsbTransferPublisher::StartTimer() |
603 { |
576 { |
604 __FNLOG("CUsbTransferPublisher::StartTimer"); |
577 if (!iTimerRunning) |
605 |
578 { |
606 if (!iTimerRunning) |
579 // EDataTransferred event every second |
607 { |
580 const TTimeIntervalMicroSeconds32 interval = 1 * 1000 * 1000; |
608 // EDataTransferred event every second |
581 TCallBack callback(PublishDataTransferredEvent, this); |
609 const TTimeIntervalMicroSeconds32 interval = 1 * 1000 * 1000; |
582 OstTrace0(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_120, "Starting timer"); |
610 TCallBack callback(PublishDataTransferredEvent, this); |
583 iTimer->Start(interval, interval, callback); |
611 __PRINT(_L("Starting timer")); |
584 iTimerRunning = ETrue; |
612 iTimer->Start(interval, interval, callback); |
585 } |
613 iTimerRunning = ETrue; |
586 } |
614 } |
|
615 } |
|
616 |
587 |
617 |
588 |
618 /** |
589 /** |
619 Ensure that the Timer is stopped |
590 Ensure that the Timer is stopped |
620 */ |
591 */ |
621 void CUsbTransferPublisher::StopTimer() |
592 void CUsbTransferPublisher::StopTimer() |
622 { |
593 { |
623 __FNLOG("CUsbTransferPublisher::StopTimer"); |
594 if (iTimerRunning) |
624 |
595 { |
625 if (iTimerRunning) |
596 OstTrace0(TRACE_SMASSSTORAGE_DRIVE, DRIVEPUBLISHER_130, "Stopping timer"); |
626 { |
597 iTimer->Cancel(); |
627 __PRINT(_L("Stopping timer")); |
598 iTimerRunning = EFalse; |
628 iTimer->Cancel(); |
599 } |
629 iTimerRunning = EFalse; |
600 } |
630 } |
|
631 } |
|
632 |
601 |
633 |
602 |
634 //---------------------------------------------------------------------------- |
603 //---------------------------------------------------------------------------- |
635 /** |
604 /** |
636 Constructor for Write property |
605 Constructor for Write property |
637 |
606 |
638 @param aArray |
607 @param aArray |
639 */ |
608 */ |
640 CUsbWriteTransferPublisher* CUsbWriteTransferPublisher::NewL(TRefBytesTransferedList aArray) |
609 CUsbWriteTransferPublisher* CUsbWriteTransferPublisher::NewL(TRefBytesTransferedList aArray) |
641 { |
610 { |
642 __FNLOG("CUsbWriteTransferPublisher::NewL"); |
611 CUsbWriteTransferPublisher* self = new (ELeave) CUsbWriteTransferPublisher(aArray); |
643 |
612 CleanupStack::PushL(self); |
644 CUsbWriteTransferPublisher* self = new (ELeave) CUsbWriteTransferPublisher(aArray); |
613 self->ConstructL(); |
645 CleanupStack::PushL(self); |
614 CleanupStack::Pop(); |
646 self->ConstructL(); |
615 return self; |
647 CleanupStack::Pop(); |
616 } |
648 return self; |
|
649 } |
|
650 |
617 |
651 |
618 |
652 CUsbWriteTransferPublisher::CUsbWriteTransferPublisher( |
619 CUsbWriteTransferPublisher::CUsbWriteTransferPublisher( |
653 TRefBytesTransferedList aArray) |
620 TRefBytesTransferedList aArray) |
654 : |
621 : |
655 CUsbTransferPublisher(EUsbMsDriveState_KBytesWritten, aArray) |
622 CUsbTransferPublisher(EUsbMsDriveState_KBytesWritten, aArray) |
656 { |
623 { |
657 } |
624 } |
658 |
625 |
659 |
626 |
660 //---------------------------------------------------------------------------- |
627 //---------------------------------------------------------------------------- |
661 /** |
628 /** |
662 Constructor for Read property |
629 Constructor for Read property |
663 |
630 |
664 @param aArray |
631 @param aArray |
665 */ |
632 */ |
666 CUsbReadTransferPublisher* CUsbReadTransferPublisher::NewL(TRefBytesTransferedList aArray) |
633 CUsbReadTransferPublisher* CUsbReadTransferPublisher::NewL(TRefBytesTransferedList aArray) |
667 { |
634 { |
668 __FNLOG("CUsbWriteTransferPublisher::NewL"); |
635 CUsbReadTransferPublisher* self = new (ELeave) CUsbReadTransferPublisher(aArray); |
669 |
636 CleanupStack::PushL(self); |
670 CUsbReadTransferPublisher* self = new (ELeave) CUsbReadTransferPublisher(aArray); |
637 self->ConstructL(); |
671 CleanupStack::PushL(self); |
638 CleanupStack::Pop(); |
672 self->ConstructL(); |
639 return self; |
673 CleanupStack::Pop(); |
640 } |
674 return self; |
|
675 } |
|
676 |
641 |
677 |
642 |
678 CUsbReadTransferPublisher::CUsbReadTransferPublisher( |
643 CUsbReadTransferPublisher::CUsbReadTransferPublisher( |
679 TRefBytesTransferedList aArray) |
644 TRefBytesTransferedList aArray) |
680 : |
645 : |
681 CUsbTransferPublisher(EUsbMsDriveState_KBytesRead, aArray) |
646 CUsbTransferPublisher(EUsbMsDriveState_KBytesRead, aArray) |
682 { |
647 { |
683 } |
648 } |
684 #endif // USB_TRANSFER_PUBLISHER |
649 #endif // USB_TRANSFER_PUBLISHER |