160 aTime; |
160 aTime; |
161 aUTime; |
161 aUTime; |
162 aDate; |
162 aDate; |
163 aReference; |
163 aReference; |
164 #endif |
164 #endif |
165 |
165 /* //This part has been commented out because of performance issue. Also this requires capability. |
166 if(RProcess().HasCapability(ECapabilityReadUserData,ECapabilityWriteUserData,NULL)) |
166 if(RProcess().HasCapability(ECapabilityReadUserData,ECapabilityWriteUserData,NULL)) |
167 { |
167 { |
168 // tm_zone updated only in this case. Otherwise always has UTC. |
168 // tm_zone updated only in this case. Otherwise always has UTC. |
169 CTzLocalizer *localizer = CTzLocalizer::NewL(); |
169 CTzLocalizer *localizer = CTzLocalizer::NewL(); |
170 CleanupStack::PushL(localizer); |
170 CleanupStack::PushL(localizer); |
182 //TODO: Value should not be hardcoded here. Get it from the struct state again. |
182 //TODO: Value should not be hardcoded here. Get it from the struct state again. |
183 TPtr8 ptr((unsigned char*)tzname[0],zoneNameDesc.Size()); |
183 TPtr8 ptr((unsigned char*)tzname[0],zoneNameDesc.Size()); |
184 CnvUtfConverter::ConvertFromUnicodeToUtf8(ptr,zoneNameDesc); |
184 CnvUtfConverter::ConvertFromUnicodeToUtf8(ptr,zoneNameDesc); |
185 CleanupStack::PopAndDestroy(timezone); |
185 CleanupStack::PopAndDestroy(timezone); |
186 CleanupStack::PopAndDestroy(localizer); |
186 CleanupStack::PopAndDestroy(localizer); |
187 } |
187 } |
188 aTmStruct->tm_zone = tzname[0]; |
188 |
189 } |
189 aTmStruct->tm_zone = tzname[0]; */ |
|
190 |
|
191 aTmStruct->tm_zone = "WILDABBR"; |
|
192 } |
190 |
193 |
191 void ConvertUtcToLocalTimeL(const time_t* aUTCTime, struct tm* const atmStruct) |
194 void ConvertUtcToLocalTimeL(const time_t* aUTCTime, struct tm* const atmStruct) |
192 { |
195 { |
193 if(!aUTCTime) |
196 if(!aUTCTime) |
194 { |
197 { |
195 User::Leave(KErrArgument); |
198 User::Leave(KErrArgument); |
196 } |
199 } |
197 |
|
198 TTime time(KEpochTime + (*aUTCTime) * (TInt64)1000000); |
200 TTime time(KEpochTime + (*aUTCTime) * (TInt64)1000000); |
199 TTime Utime(time); |
201 TTime Utime(time); |
200 |
202 |
201 // Cache Logic. |
203 // Cache Logic. |
202 TTimeIntervalSeconds UtcOffset = User::UTCOffset(); |
204 TTimeIntervalSeconds UtcOffset = User::UTCOffset(); |
214 cachetm.tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so |
216 cachetm.tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so |
215 *atmStruct = cachetm; |
217 *atmStruct = cachetm; |
216 return; |
218 return; |
217 } |
219 } |
218 |
220 |
219 RTz tzServer; |
|
220 User::LeaveIfError(tzServer.Connect()); |
|
221 CleanupClosePushL(tzServer); |
|
222 |
|
223 TDateTime tdt = time.DateTime(); |
221 TDateTime tdt = time.DateTime(); |
224 |
222 |
225 //enable the cache |
223 //enable the cache |
226 CTzConverter* ctzConverter = CTzConverter::NewL(tzServer); |
224 CTzConverter* ctzConverter = CTzConverter::NewL(Backend()->TZServer()); |
|
225 |
227 CleanupStack::PushL(ctzConverter); |
226 CleanupStack::PushL(ctzConverter); |
228 if(ctzConverter->ConvertToLocalTime(time) == KErrNone) |
227 if(ctzConverter->ConvertToLocalTime(time) == KErrNone) |
229 { |
228 { |
230 tdt = time.DateTime(); |
229 tdt = time.DateTime(); |
231 atmStruct->tm_sec = tdt.Second(); |
230 atmStruct->tm_sec = tdt.Second(); |
242 TInt timeZoneId = ctzConverter->CurrentTzId(); |
241 TInt timeZoneId = ctzConverter->CurrentTzId(); |
243 CTzId* zoneid = CTzId::NewL((TUint)timeZoneId); |
242 CTzId* zoneid = CTzId::NewL((TUint)timeZoneId); |
244 CleanupStack::PushL(zoneid); |
243 CleanupStack::PushL(zoneid); |
245 |
244 |
246 atmStruct->tm_isdst = -1; |
245 atmStruct->tm_isdst = -1; |
247 UpdateDstAndTznameL(tzServer, *zoneid, atmStruct, time, Utime, tdt, ETzWallTimeReference); |
246 UpdateDstAndTznameL(Backend()->TZServer(), *zoneid, atmStruct, time, Utime, tdt, ETzWallTimeReference); |
248 CleanupStack::PopAndDestroy(zoneid); |
247 CleanupStack::PopAndDestroy(zoneid); |
249 } |
248 } |
250 CleanupStack::PopAndDestroy(2); |
249 |
|
250 |
|
251 CleanupStack::PopAndDestroy(1); |
251 cachetm = *atmStruct; |
252 cachetm = *atmStruct; |
252 } |
253 } |
253 |
254 |
254 void ConvertLocalToUtcTimeL(time_t* aUTCTime, struct tm* const aTmStruct) |
255 void ConvertLocalToUtcTimeL(time_t* aUTCTime, struct tm* const aTmStruct) |
255 { |
256 { |
277 TInt64 epochRefTime = utcTimeMicroSec - KEpochTime; |
278 TInt64 epochRefTime = utcTimeMicroSec - KEpochTime; |
278 (*aUTCTime) = (TInt) (epochRefTime / 1000000); |
279 (*aUTCTime) = (TInt) (epochRefTime / 1000000); |
279 return; |
280 return; |
280 } |
281 } |
281 |
282 |
282 RTz tzServer; |
283 |
283 User::LeaveIfError(tzServer.Connect()); |
284 CTzConverter* ctzConverter = CTzConverter::NewL(Backend()->TZServer()); |
284 CleanupClosePushL(tzServer); |
|
285 |
|
286 CTzConverter* ctzConverter = CTzConverter::NewL(tzServer); |
|
287 CleanupStack::PushL(ctzConverter); |
285 CleanupStack::PushL(ctzConverter); |
288 /* Following fields are updated if successful: |
286 /* Following fields are updated if successful: |
289 * tm_wday |
287 * tm_wday |
290 * tm_yday |
288 * tm_yday |
291 * tm_isdst |
289 * tm_isdst |
305 TInt timeZoneId = ctzConverter->CurrentTzId(); |
303 TInt timeZoneId = ctzConverter->CurrentTzId(); |
306 CTzId* zoneid = CTzId::NewL((TUint)timeZoneId); |
304 CTzId* zoneid = CTzId::NewL((TUint)timeZoneId); |
307 CleanupStack::PushL(zoneid); |
305 CleanupStack::PushL(zoneid); |
308 |
306 |
309 aTmStruct->tm_isdst = -1; |
307 aTmStruct->tm_isdst = -1; |
310 UpdateDstAndTznameL(tzServer, *zoneid, aTmStruct, oldTime, time, tdt, ETzUtcTimeReference); |
308 UpdateDstAndTznameL(Backend()->TZServer(), *zoneid, aTmStruct, oldTime, time, tdt, ETzUtcTimeReference); |
311 CleanupStack::PopAndDestroy(zoneid); |
309 CleanupStack::PopAndDestroy(zoneid); |
312 } |
310 } |
313 cachetm = *aTmStruct; |
311 cachetm = *aTmStruct; |
314 CleanupStack::PopAndDestroy(2); |
312 CleanupStack::PopAndDestroy(1); |
315 } |
313 } |
316 |
314 |
317 // converts a UTC time to local time, or, local time to UTC time. |
315 // converts a UTC time to local time, or, local time to UTC time. |
318 TInt ConvertTime(const TInt atimeConverFlg, time_t *aUTCTime, struct tm *const atmStruct) |
316 TInt ConvertTime(const TInt atimeConverFlg, time_t *aUTCTime, struct tm *const atmStruct) |
319 { |
317 { |
320 TInt err = 0; |
318 TInt err = 0; |
|
319 |
321 CActiveScheduler* oldAs = CActiveScheduler::Current(); |
320 CActiveScheduler* oldAs = CActiveScheduler::Current(); |
322 RHeap* oldHeap = User::SwitchHeap(Backend()->Heap()); |
321 RHeap* oldHeap = User::SwitchHeap(Backend()->Heap()); |
323 CActiveScheduler* newAs = new CActiveScheduler(); |
322 CActiveScheduler* newAs = new CActiveScheduler(); |
324 User::SwitchHeap(oldHeap); |
323 User::SwitchHeap(oldHeap); |
325 if(!newAs) |
324 if(!newAs) |
333 } |
332 } |
334 else |
333 else |
335 { |
334 { |
336 CActiveScheduler::Install(newAs); |
335 CActiveScheduler::Install(newAs); |
337 } |
336 } |
338 |
337 |
|
338 oldHeap = User::SwitchHeap(Backend()->Heap()); |
339 // Cleanup stack needed |
339 // Cleanup stack needed |
340 CTrapCleanup* cleanup=CTrapCleanup::New(); |
340 CTrapCleanup* cleanup=CTrapCleanup::New(); |
|
341 |
341 if (cleanup) |
342 if (cleanup) |
342 { |
343 { |
343 if(EUtcToLocal == atimeConverFlg) |
344 if(EUtcToLocal == atimeConverFlg) |
344 { |
345 { |
345 TRAP(err, ConvertUtcToLocalTimeL(aUTCTime, atmStruct)); |
346 TRAP(err, ConvertUtcToLocalTimeL(aUTCTime, atmStruct)); |