author | Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com> |
Fri, 11 Jun 2010 15:26:22 +0300 | |
changeset 34 | 5fae379060a7 |
parent 31 | ce057bb09d0b |
child 45 | 4b03adbd26ca |
child 68 | ff3fc7722556 |
permissions | -rw-r--r-- |
31 | 1 |
/* |
2 |
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 |
* All rights reserved. |
|
4 |
* This component and the accompanying materials are made available |
|
5 |
* under the terms of "Eclipse Public License v1.0" |
|
6 |
* which accompanies this distribution, and is available |
|
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: This is a project specific include file for building the |
|
15 |
* clock related functions as part of libc library. |
|
16 |
* |
|
17 |
*/ |
|
18 |
||
19 |
||
20 |
#include <e32base.h> |
|
21 |
#include <e32cons.h> |
|
22 |
#include <tz.h> |
|
23 |
#include <tzconverter.h> |
|
34
5fae379060a7
Revision: 201023
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
31
diff
changeset
|
24 |
#include "tzlocalizer.h" |
5fae379060a7
Revision: 201023
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
31
diff
changeset
|
25 |
#include "tzlocalizationdatatypes.h" |
31 | 26 |
#include "vtzrules.h" |
27 |
#include "utf.h" |
|
28 |
#include "timefuncs.h" |
|
29 |
#include "lposix.h" |
|
30 |
#include "sysif.h" |
|
31 |
#include "libc_wsd_defs.h" |
|
32 |
||
33 |
// This represents the base EpochTime in microseconds, |
|
34 |
// which happens to be January 1, 1970 (midnight UTC/GMT), |
|
35 |
// not counting leap seconds. This effectively represents |
|
36 |
// the number of microseconds in 1970 years. |
|
37 |
static const TInt64 KEpochTime = 62168256000000000; |
|
38 |
||
39 |
||
40 |
||
41 |
#ifndef EMULATOR |
|
42 |
struct tm cachetm; |
|
43 |
time_t prevchange; |
|
44 |
time_t nextchange; |
|
45 |
#else //EMULATOR |
|
46 |
||
47 |
||
48 |
||
49 |
GET_GLOBAL_VAR_FROM_TLS(cachetm, struct tm) |
|
50 |
#define cachetm (*GET_WSD_VAR_NAME(cachetm, g)()) |
|
51 |
GET_GLOBAL_VAR_FROM_TLS(prevchange, time_t) |
|
52 |
#define prevchange (*GET_WSD_VAR_NAME(prevchange, g)()) |
|
53 |
GET_GLOBAL_VAR_FROM_TLS(nextchange, time_t) |
|
54 |
#define nextchange (*GET_WSD_VAR_NAME(nextchange, g)()) |
|
55 |
#endif //EMULATOR |
|
56 |
||
57 |
#if !defined(__SERIES60_30__) |
|
58 |
TTzTimeReference FindChangeBracket(TTime& aTime ,TTime& aUTime, CVTzActualisedRules& aRule,TBool& aDstOn) |
|
59 |
{ |
|
60 |
TInt cnt = aRule.Count(); |
|
61 |
TInt lowestOffset = -1, curOffset=-1; |
|
62 |
TBool isInit = EFalse; |
|
63 |
TTime CurTime(aTime); |
|
64 |
TTime Previous(-1), Next(-1); |
|
65 |
TTzTimeReference ref(ETzWallTimeReference); |
|
66 |
||
67 |
//datetime to be created from the UTC time. |
|
68 |
TDateTime dateTime = aUTime.DateTime(); |
|
69 |
||
70 |
// Initially set aDstOn to False |
|
71 |
aDstOn = EFalse; |
|
72 |
||
73 |
// Loop to find the lowest time offset applicable in the year. |
|
74 |
for(TInt idx=0; idx<cnt; idx++) |
|
75 |
{ |
|
76 |
TVTzActualisedRule& Actual = aRule[idx]; |
|
77 |
if (Actual.iTimeOfChange.DateTime().Year() == dateTime.Year()) |
|
78 |
{ |
|
79 |
if (!isInit) |
|
80 |
{ |
|
81 |
lowestOffset = Actual.iNewOffset; |
|
82 |
isInit = ETrue; |
|
83 |
} |
|
84 |
||
85 |
if (isInit && Actual.iNewOffset < lowestOffset) |
|
86 |
{ |
|
87 |
lowestOffset = Actual.iNewOffset; |
|
88 |
} |
|
89 |
} |
|
90 |
} |
|
91 |
// Loop to find the current offset, previous time of change and the next time of change. |
|
92 |
for(TInt idx=0; idx<cnt; idx++) |
|
93 |
{ |
|
94 |
TVTzActualisedRule& Actual = aRule[idx]; |
|
95 |
if(Actual.iTimeReference == ETzUtcTimeReference && CurTime != aUTime) |
|
96 |
{ |
|
97 |
CurTime = aUTime; |
|
98 |
ref = ETzUtcTimeReference; |
|
99 |
} |
|
100 |
// Rules are arranged in increasing order of iTimeofChange |
|
101 |
if(CurTime >= Actual.iTimeOfChange) |
|
102 |
{ |
|
103 |
Previous = Actual.iTimeOfChange; |
|
104 |
curOffset = Actual.iNewOffset; |
|
105 |
} |
|
106 |
else |
|
107 |
{ |
|
108 |
Next = Actual.iTimeOfChange; |
|
109 |
break; |
|
110 |
} |
|
111 |
} |
|
112 |
/* |
|
113 |
* If the Next and Previous were not set due to some reason, |
|
114 |
* Set them to one year after and one year before the time passed. |
|
115 |
*/ |
|
116 |
if(Next == -1) |
|
117 |
{ |
|
118 |
/* Next year */ |
|
119 |
Next = CurTime + (TTimeIntervalSeconds)(365*86400); |
|
120 |
} |
|
121 |
if (Previous == -1) |
|
122 |
{ |
|
123 |
/* Prev Year */ |
|
124 |
Previous = CurTime - (TTimeIntervalSeconds)(365*86400); |
|
125 |
} |
|
126 |
aTime = Previous; |
|
127 |
aUTime = Next; |
|
128 |
if(lowestOffset != -1 && curOffset > lowestOffset) |
|
129 |
{ |
|
130 |
aDstOn = ETrue; |
|
131 |
} |
|
132 |
return ref; |
|
133 |
} |
|
134 |
#endif |
|
135 |
||
136 |
void UpdateDstAndTznameL(RTz &aServer,CTzId& aId,struct tm* aTmStruct, TTime aTime, TTime aUTime, TDateTime aDate, TTzTimeReference aReference) |
|
137 |
{ |
|
138 |
#if !defined(__SERIES60_30__) |
|
139 |
CTzRules* zonerules = aServer.GetTimeZoneRulesL(aId, aTime, aTime, aReference); |
|
140 |
CleanupStack::PushL(zonerules); |
|
141 |
CVTzActualisedRules* actual = CVTzActualisedRules::NewL(aDate.Year()-1, aDate.Year()+1); |
|
142 |
CleanupStack::PushL(actual); |
|
143 |
zonerules->GetActualisedRulesL(*actual); |
|
144 |
TTime PrevTime(aTime), NextTime(aUTime); |
|
145 |
TBool IsDstOn; |
|
146 |
/* Send local TTimes */ |
|
147 |
if(FindChangeBracket(PrevTime, NextTime, *actual, IsDstOn)== ETzWallTimeReference) |
|
148 |
{ |
|
149 |
aServer.ConvertToUniversalTime(PrevTime,aId); |
|
150 |
aServer.ConvertToUniversalTime(NextTime,aId); |
|
151 |
} |
|
152 |
prevchange = (PrevTime.Int64() - KEpochTime)/1000000; |
|
153 |
nextchange = (NextTime.Int64() - KEpochTime)/1000000; |
|
154 |
||
155 |
aTmStruct->tm_isdst = IsDstOn; |
|
156 |
CleanupStack::PopAndDestroy(actual); |
|
157 |
CleanupStack::PopAndDestroy(zonerules); |
|
158 |
#else // __SERIES60_30__ defined |
|
159 |
aServer; |
|
160 |
aTime; |
|
161 |
aUTime; |
|
162 |
aDate; |
|
163 |
aReference; |
|
164 |
#endif |
|
165 |
/* //This part has been commented out because of performance issue. Also this requires capability. |
|
166 |
if(RProcess().HasCapability(ECapabilityReadUserData,ECapabilityWriteUserData,NULL)) |
|
167 |
{ |
|
168 |
// tm_zone updated only in this case. Otherwise always has UTC. |
|
169 |
CTzLocalizer *localizer = CTzLocalizer::NewL(); |
|
170 |
CleanupStack::PushL(localizer); |
|
171 |
CTzLocalizedTimeZone* timezone = localizer->GetLocalizedTimeZoneL(aId.TimeZoneNumericID()); |
|
172 |
CleanupStack::PushL(timezone); |
|
173 |
TPtrC zoneNameDesc; |
|
174 |
if (aTmStruct->tm_isdst) |
|
175 |
{ |
|
176 |
zoneNameDesc.Set(timezone->ShortDaylightName()); |
|
177 |
} |
|
178 |
else |
|
179 |
{ |
|
180 |
zoneNameDesc.Set(timezone->ShortStandardName()); |
|
181 |
} |
|
182 |
//TODO: Value should not be hardcoded here. Get it from the struct state again. |
|
183 |
TPtr8 ptr((unsigned char*)tzname[0],zoneNameDesc.Size()); |
|
184 |
CnvUtfConverter::ConvertFromUnicodeToUtf8(ptr,zoneNameDesc); |
|
185 |
CleanupStack::PopAndDestroy(timezone); |
|
186 |
CleanupStack::PopAndDestroy(localizer); |
|
187 |
} |
|
188 |
||
189 |
aTmStruct->tm_zone = tzname[0]; */ |
|
190 |
||
191 |
aTmStruct->tm_zone = "WILDABBR"; |
|
192 |
} |
|
193 |
||
194 |
void ConvertUtcToLocalTimeL(const time_t* aUTCTime, struct tm* const atmStruct) |
|
195 |
{ |
|
196 |
if(!aUTCTime) |
|
197 |
{ |
|
198 |
User::Leave(KErrArgument); |
|
199 |
} |
|
200 |
TTime time(KEpochTime + (*aUTCTime) * (TInt64)1000000); |
|
201 |
TTime Utime(time); |
|
202 |
||
203 |
// Cache Logic. |
|
204 |
TTimeIntervalSeconds UtcOffset = User::UTCOffset(); |
|
205 |
if( cachetm.tm_gmtoff == UtcOffset.Int() && prevchange <= *aUTCTime && *aUTCTime<= nextchange) |
|
206 |
{ |
|
207 |
time += UtcOffset; // Convert to local time. |
|
208 |
TDateTime tdt = time.DateTime(); |
|
209 |
cachetm.tm_sec = tdt.Second(); |
|
210 |
cachetm.tm_min = tdt.Minute(); |
|
211 |
cachetm.tm_hour = tdt.Hour(); |
|
212 |
cachetm.tm_mday = tdt.Day() + 1; |
|
213 |
cachetm.tm_mon = tdt.Month(); |
|
214 |
cachetm.tm_year = tdt.Year() - 1900; // This is as per the tm structure format. |
|
215 |
cachetm.tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1. |
|
216 |
cachetm.tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so |
|
217 |
*atmStruct = cachetm; |
|
218 |
return; |
|
219 |
} |
|
220 |
||
221 |
TDateTime tdt = time.DateTime(); |
|
222 |
||
223 |
//enable the cache |
|
224 |
CTzConverter* ctzConverter = CTzConverter::NewL(Backend()->TZServer()); |
|
225 |
||
226 |
CleanupStack::PushL(ctzConverter); |
|
227 |
if(ctzConverter->ConvertToLocalTime(time) == KErrNone) |
|
228 |
{ |
|
229 |
tdt = time.DateTime(); |
|
230 |
atmStruct->tm_sec = tdt.Second(); |
|
231 |
atmStruct->tm_min = tdt.Minute(); |
|
232 |
atmStruct->tm_hour = tdt.Hour(); |
|
233 |
atmStruct->tm_mday = tdt.Day() + 1; |
|
234 |
atmStruct->tm_mon = tdt.Month(); |
|
235 |
atmStruct->tm_year = tdt.Year() - 1900; // This is as per the tm structure format. |
|
236 |
atmStruct->tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1. |
|
237 |
atmStruct->tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so |
|
238 |
||
239 |
atmStruct->tm_gmtoff = (time.Int64() - Utime.Int64())/1000000; |
|
240 |
||
241 |
TInt timeZoneId = ctzConverter->CurrentTzId(); |
|
242 |
CTzId* zoneid = CTzId::NewL((TUint)timeZoneId); |
|
243 |
CleanupStack::PushL(zoneid); |
|
244 |
||
245 |
atmStruct->tm_isdst = -1; |
|
246 |
UpdateDstAndTznameL(Backend()->TZServer(), *zoneid, atmStruct, time, Utime, tdt, ETzWallTimeReference); |
|
247 |
CleanupStack::PopAndDestroy(zoneid); |
|
248 |
} |
|
249 |
||
250 |
||
251 |
CleanupStack::PopAndDestroy(1); |
|
252 |
cachetm = *atmStruct; |
|
253 |
} |
|
254 |
||
255 |
void ConvertLocalToUtcTimeL(time_t* aUTCTime, struct tm* const aTmStruct) |
|
256 |
{ |
|
257 |
if(!aTmStruct || aTmStruct->tm_year < 0 || aTmStruct->tm_mon < 0 || aTmStruct->tm_mday < 1 || aTmStruct->tm_hour < 0 || aTmStruct->tm_min < 0 || aTmStruct->tm_sec < 0 ) |
|
258 |
{ |
|
259 |
User::Leave(KErrArgument); |
|
260 |
} |
|
261 |
||
262 |
TDateTime tdt(aTmStruct->tm_year + 1900, (TMonth)aTmStruct->tm_mon, aTmStruct->tm_mday-1, |
|
263 |
aTmStruct->tm_hour, aTmStruct->tm_min, aTmStruct->tm_sec, 0); |
|
264 |
TTime time(tdt); |
|
265 |
TTime oldTime(time); |
|
266 |
||
267 |
// Cache Logic |
|
268 |
TTimeIntervalSeconds UtcOffset = User::UTCOffset(); |
|
269 |
if(cachetm.tm_gmtoff == UtcOffset.Int() && cachetm.tm_year == aTmStruct->tm_year && cachetm.tm_mon == aTmStruct->tm_mon && cachetm.tm_mday == aTmStruct->tm_mday) |
|
270 |
{ |
|
271 |
aTmStruct->tm_gmtoff = cachetm.tm_gmtoff; |
|
272 |
aTmStruct->tm_isdst = cachetm.tm_isdst; |
|
273 |
aTmStruct->tm_zone = cachetm.tm_zone; |
|
274 |
aTmStruct->tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1. |
|
275 |
aTmStruct->tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so |
|
276 |
time -= UtcOffset; // Converting to UTC time. |
|
277 |
TInt64 utcTimeMicroSec = time.Int64(); |
|
278 |
TInt64 epochRefTime = utcTimeMicroSec - KEpochTime; |
|
279 |
(*aUTCTime) = (TInt) (epochRefTime / 1000000); |
|
280 |
return; |
|
281 |
} |
|
282 |
||
283 |
||
284 |
CTzConverter* ctzConverter = CTzConverter::NewL(Backend()->TZServer()); |
|
285 |
CleanupStack::PushL(ctzConverter); |
|
286 |
/* Following fields are updated if successful: |
|
287 |
* tm_wday |
|
288 |
* tm_yday |
|
289 |
* tm_isdst |
|
290 |
* tm_gmtoffset |
|
291 |
* tm_zone ( Conditional on capabilities available) |
|
292 |
*/ |
|
293 |
if(ctzConverter->ConvertToUniversalTime(time) == KErrNone) |
|
294 |
{ |
|
295 |
//conversion successful |
|
296 |
TInt64 utcTimeMicroSec = time.Int64(); |
|
297 |
TInt64 epochRefTime = utcTimeMicroSec - KEpochTime; |
|
298 |
(*aUTCTime) = (TInt) (epochRefTime / 1000000); |
|
299 |
aTmStruct->tm_wday = (oldTime.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1. |
|
300 |
aTmStruct->tm_yday = oldTime.DayNoInYear()-1; // Note: first day of the year is considered as 1, so |
|
301 |
aTmStruct->tm_gmtoff = (oldTime.Int64() - utcTimeMicroSec)/1000000; |
|
302 |
||
303 |
TInt timeZoneId = ctzConverter->CurrentTzId(); |
|
304 |
CTzId* zoneid = CTzId::NewL((TUint)timeZoneId); |
|
305 |
CleanupStack::PushL(zoneid); |
|
306 |
||
307 |
aTmStruct->tm_isdst = -1; |
|
308 |
UpdateDstAndTznameL(Backend()->TZServer(), *zoneid, aTmStruct, oldTime, time, tdt, ETzUtcTimeReference); |
|
309 |
CleanupStack::PopAndDestroy(zoneid); |
|
310 |
} |
|
311 |
cachetm = *aTmStruct; |
|
312 |
CleanupStack::PopAndDestroy(1); |
|
313 |
} |
|
314 |
||
315 |
// converts a UTC time to local time, or, local time to UTC time. |
|
316 |
TInt ConvertTime(const TInt atimeConverFlg, time_t *aUTCTime, struct tm *const atmStruct) |
|
317 |
{ |
|
318 |
TInt err = 0; |
|
319 |
||
320 |
CActiveScheduler* oldAs = CActiveScheduler::Current(); |
|
321 |
RHeap* oldHeap = User::SwitchHeap(Backend()->Heap()); |
|
322 |
CActiveScheduler* newAs = new CActiveScheduler(); |
|
323 |
User::SwitchHeap(oldHeap); |
|
324 |
if(!newAs) |
|
325 |
{ |
|
326 |
errno = ENOMEM; |
|
327 |
return ENOMEM; |
|
328 |
} |
|
329 |
if(oldAs) |
|
330 |
{ |
|
331 |
(void)CActiveScheduler::Replace(newAs); |
|
332 |
} |
|
333 |
else |
|
334 |
{ |
|
335 |
CActiveScheduler::Install(newAs); |
|
336 |
} |
|
337 |
||
338 |
oldHeap = User::SwitchHeap(Backend()->Heap()); |
|
339 |
// Cleanup stack needed |
|
340 |
CTrapCleanup* cleanup=CTrapCleanup::New(); |
|
341 |
||
342 |
if (cleanup) |
|
343 |
{ |
|
344 |
if(EUtcToLocal == atimeConverFlg) |
|
345 |
{ |
|
346 |
TRAP(err, ConvertUtcToLocalTimeL(aUTCTime, atmStruct)); |
|
347 |
} |
|
348 |
else if(ELocalToUtc == atimeConverFlg) |
|
349 |
{ |
|
350 |
TRAP(err, ConvertLocalToUtcTimeL(aUTCTime, atmStruct)); |
|
351 |
} |
|
352 |
delete cleanup; |
|
353 |
} |
|
354 |
else |
|
355 |
{ |
|
356 |
err = ENOMEM; |
|
357 |
} |
|
358 |
if(oldAs) |
|
359 |
{ |
|
360 |
(void)CActiveScheduler::Replace(oldAs); |
|
361 |
} |
|
362 |
||
363 |
||
364 |
delete newAs; |
|
365 |
User::SwitchHeap(oldHeap); |
|
366 |
return MapError(err,errno); |
|
367 |
} |
|
368 |