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>
|
|
24 |
#include "TzLocalizer.h"
|
|
25 |
#include "TzLocalizationDataTypes.h"
|
|
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 |
|