/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: This is a project specific include file for building the
* clock related functions as part of libc library.
*
*/
#include <e32base.h>
#include <e32cons.h>
#include <tz.h>
#include <tzconverter.h>
#include "tzlocalizer.h"
#include "tzlocalizationdatatypes.h"
#include "vtzrules.h"
#include "utf.h"
#include "timefuncs.h"
#include "lposix.h"
#include "sysif.h"
#include "libc_wsd_defs.h"
// This represents the base EpochTime in microseconds,
// which happens to be January 1, 1970 (midnight UTC/GMT),
// not counting leap seconds. This effectively represents
// the number of microseconds in 1970 years.
static const TInt64 KEpochTime = 62168256000000000;
#ifndef EMULATOR
struct tm cachetm;
time_t prevchange;
time_t nextchange;
#else //EMULATOR
GET_GLOBAL_VAR_FROM_TLS(cachetm, struct tm)
#define cachetm (*GET_WSD_VAR_NAME(cachetm, g)())
GET_GLOBAL_VAR_FROM_TLS(prevchange, time_t)
#define prevchange (*GET_WSD_VAR_NAME(prevchange, g)())
GET_GLOBAL_VAR_FROM_TLS(nextchange, time_t)
#define nextchange (*GET_WSD_VAR_NAME(nextchange, g)())
#endif //EMULATOR
#if !defined(__SERIES60_30__)
TTzTimeReference FindChangeBracket(TTime& aTime ,TTime& aUTime, CVTzActualisedRules& aRule,TBool& aDstOn)
{
TInt cnt = aRule.Count();
TInt lowestOffset = -1, curOffset=-1;
TBool isInit = EFalse;
TTime CurTime(aTime);
TTime Previous(-1), Next(-1);
TTzTimeReference ref(ETzWallTimeReference);
//datetime to be created from the UTC time.
TDateTime dateTime = aUTime.DateTime();
// Initially set aDstOn to False
aDstOn = EFalse;
// Loop to find the lowest time offset applicable in the year.
for(TInt idx=0; idx<cnt; idx++)
{
TVTzActualisedRule& Actual = aRule[idx];
if (Actual.iTimeOfChange.DateTime().Year() == dateTime.Year())
{
if (!isInit)
{
lowestOffset = Actual.iNewOffset;
isInit = ETrue;
}
if (isInit && Actual.iNewOffset < lowestOffset)
{
lowestOffset = Actual.iNewOffset;
}
}
}
// Loop to find the current offset, previous time of change and the next time of change.
for(TInt idx=0; idx<cnt; idx++)
{
TVTzActualisedRule& Actual = aRule[idx];
if(Actual.iTimeReference == ETzUtcTimeReference && CurTime != aUTime)
{
CurTime = aUTime;
ref = ETzUtcTimeReference;
}
// Rules are arranged in increasing order of iTimeofChange
if(CurTime >= Actual.iTimeOfChange)
{
Previous = Actual.iTimeOfChange;
curOffset = Actual.iNewOffset;
}
else
{
Next = Actual.iTimeOfChange;
break;
}
}
/*
* If the Next and Previous were not set due to some reason,
* Set them to one year after and one year before the time passed.
*/
if(Next == -1)
{
/* Next year */
Next = CurTime + (TTimeIntervalSeconds)(365*86400);
}
if (Previous == -1)
{
/* Prev Year */
Previous = CurTime - (TTimeIntervalSeconds)(365*86400);
}
aTime = Previous;
aUTime = Next;
if(lowestOffset != -1 && curOffset > lowestOffset)
{
aDstOn = ETrue;
}
return ref;
}
#endif
void UpdateDstAndTznameL(RTz &aServer,CTzId& aId,struct tm* aTmStruct, TTime aTime, TTime aUTime, TDateTime aDate, TTzTimeReference aReference)
{
#if !defined(__SERIES60_30__)
CTzRules* zonerules = aServer.GetTimeZoneRulesL(aId, aTime, aTime, aReference);
CleanupStack::PushL(zonerules);
CVTzActualisedRules* actual = CVTzActualisedRules::NewL(aDate.Year()-1, aDate.Year()+1);
CleanupStack::PushL(actual);
zonerules->GetActualisedRulesL(*actual);
TTime PrevTime(aTime), NextTime(aUTime);
TBool IsDstOn;
/* Send local TTimes */
if(FindChangeBracket(PrevTime, NextTime, *actual, IsDstOn)== ETzWallTimeReference)
{
aServer.ConvertToUniversalTime(PrevTime,aId);
aServer.ConvertToUniversalTime(NextTime,aId);
}
prevchange = (PrevTime.Int64() - KEpochTime)/1000000;
nextchange = (NextTime.Int64() - KEpochTime)/1000000;
aTmStruct->tm_isdst = IsDstOn;
CleanupStack::PopAndDestroy(actual);
CleanupStack::PopAndDestroy(zonerules);
#else // __SERIES60_30__ defined
aServer;
aTime;
aUTime;
aDate;
aReference;
#endif
/* //This part has been commented out because of performance issue. Also this requires capability.
if(RProcess().HasCapability(ECapabilityReadUserData,ECapabilityWriteUserData,NULL))
{
// tm_zone updated only in this case. Otherwise always has UTC.
CTzLocalizer *localizer = CTzLocalizer::NewL();
CleanupStack::PushL(localizer);
CTzLocalizedTimeZone* timezone = localizer->GetLocalizedTimeZoneL(aId.TimeZoneNumericID());
CleanupStack::PushL(timezone);
TPtrC zoneNameDesc;
if (aTmStruct->tm_isdst)
{
zoneNameDesc.Set(timezone->ShortDaylightName());
}
else
{
zoneNameDesc.Set(timezone->ShortStandardName());
}
//TODO: Value should not be hardcoded here. Get it from the struct state again.
TPtr8 ptr((unsigned char*)tzname[0],zoneNameDesc.Size());
CnvUtfConverter::ConvertFromUnicodeToUtf8(ptr,zoneNameDesc);
CleanupStack::PopAndDestroy(timezone);
CleanupStack::PopAndDestroy(localizer);
}
aTmStruct->tm_zone = tzname[0]; */
aTmStruct->tm_zone = "WILDABBR";
}
void ConvertUtcToLocalTimeL(const time_t* aUTCTime, struct tm* const atmStruct)
{
if(!aUTCTime)
{
User::Leave(KErrArgument);
}
TTime time(KEpochTime + (*aUTCTime) * (TInt64)1000000);
TTime Utime(time);
// Cache Logic.
TTimeIntervalSeconds UtcOffset = User::UTCOffset();
if( cachetm.tm_gmtoff == UtcOffset.Int() && prevchange <= *aUTCTime && *aUTCTime<= nextchange)
{
time += UtcOffset; // Convert to local time.
TDateTime tdt = time.DateTime();
cachetm.tm_sec = tdt.Second();
cachetm.tm_min = tdt.Minute();
cachetm.tm_hour = tdt.Hour();
cachetm.tm_mday = tdt.Day() + 1;
cachetm.tm_mon = tdt.Month();
cachetm.tm_year = tdt.Year() - 1900; // This is as per the tm structure format.
cachetm.tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1.
cachetm.tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so
*atmStruct = cachetm;
return;
}
TDateTime tdt = time.DateTime();
//enable the cache
TInt status = KErrNone;
RTz& rtzServer = Backend()->TZServer(status);
if(status != KErrNone)
User::Leave(status);
CTzConverter* ctzConverter = CTzConverter::NewL(rtzServer);
CleanupStack::PushL(ctzConverter);
if(ctzConverter->ConvertToLocalTime(time) == KErrNone)
{
tdt = time.DateTime();
atmStruct->tm_sec = tdt.Second();
atmStruct->tm_min = tdt.Minute();
atmStruct->tm_hour = tdt.Hour();
atmStruct->tm_mday = tdt.Day() + 1;
atmStruct->tm_mon = tdt.Month();
atmStruct->tm_year = tdt.Year() - 1900; // This is as per the tm structure format.
atmStruct->tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1.
atmStruct->tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so
atmStruct->tm_gmtoff = (time.Int64() - Utime.Int64())/1000000;
TInt timeZoneId = ctzConverter->CurrentTzId();
CTzId* zoneid = CTzId::NewL((TUint)timeZoneId);
CleanupStack::PushL(zoneid);
atmStruct->tm_isdst = -1;
UpdateDstAndTznameL(rtzServer, *zoneid, atmStruct, time, Utime, tdt, ETzWallTimeReference);
CleanupStack::PopAndDestroy(zoneid);
}
CleanupStack::PopAndDestroy(1);
cachetm = *atmStruct;
}
void ConvertLocalToUtcTimeL(time_t* aUTCTime, struct tm* const aTmStruct)
{
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 )
{
User::Leave(KErrArgument);
}
TDateTime tdt(aTmStruct->tm_year + 1900, (TMonth)aTmStruct->tm_mon, aTmStruct->tm_mday-1,
aTmStruct->tm_hour, aTmStruct->tm_min, aTmStruct->tm_sec, 0);
TTime time(tdt);
TTime oldTime(time);
// Cache Logic
TTimeIntervalSeconds UtcOffset = User::UTCOffset();
if(cachetm.tm_gmtoff == UtcOffset.Int() && cachetm.tm_year == aTmStruct->tm_year && cachetm.tm_mon == aTmStruct->tm_mon && cachetm.tm_mday == aTmStruct->tm_mday)
{
aTmStruct->tm_gmtoff = cachetm.tm_gmtoff;
aTmStruct->tm_isdst = cachetm.tm_isdst;
aTmStruct->tm_zone = cachetm.tm_zone;
aTmStruct->tm_wday = (time.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1.
aTmStruct->tm_yday = time.DayNoInYear()-1; // Note: first day of the year is considered as 1, so
time -= UtcOffset; // Converting to UTC time.
TInt64 utcTimeMicroSec = time.Int64();
TInt64 epochRefTime = utcTimeMicroSec - KEpochTime;
(*aUTCTime) = (TInt) (epochRefTime / 1000000);
return;
}
TInt status = KErrNone;
RTz& rtzServer = Backend()->TZServer(status);
if(status != KErrNone)
User::Leave(status);
CTzConverter* ctzConverter = CTzConverter::NewL(rtzServer);
CleanupStack::PushL(ctzConverter);
/* Following fields are updated if successful:
* tm_wday
* tm_yday
* tm_isdst
* tm_gmtoffset
* tm_zone ( Conditional on capabilities available)
*/
if(ctzConverter->ConvertToUniversalTime(time) == KErrNone)
{
//conversion successful
TInt64 utcTimeMicroSec = time.Int64();
TInt64 epochRefTime = utcTimeMicroSec - KEpochTime;
(*aUTCTime) = (TInt) (epochRefTime / 1000000);
aTmStruct->tm_wday = (oldTime.DayNoInWeek()+1)%7; // Note: first day of the week is considered as Monday, so adding +1.
aTmStruct->tm_yday = oldTime.DayNoInYear()-1; // Note: first day of the year is considered as 1, so
aTmStruct->tm_gmtoff = (oldTime.Int64() - utcTimeMicroSec)/1000000;
TInt timeZoneId = ctzConverter->CurrentTzId();
CTzId* zoneid = CTzId::NewL((TUint)timeZoneId);
CleanupStack::PushL(zoneid);
aTmStruct->tm_isdst = -1;
UpdateDstAndTznameL(rtzServer, *zoneid, aTmStruct, oldTime, time, tdt, ETzUtcTimeReference);
CleanupStack::PopAndDestroy(zoneid);
}
cachetm = *aTmStruct;
CleanupStack::PopAndDestroy(1);
}
// converts a UTC time to local time, or, local time to UTC time.
TInt ConvertTime(const TInt atimeConverFlg, time_t *aUTCTime, struct tm *const atmStruct)
{
TInt err = 0;
CActiveScheduler* oldAs = CActiveScheduler::Current();
RHeap* oldHeap = User::SwitchHeap(Backend()->Heap());
CActiveScheduler* newAs = new CActiveScheduler();
User::SwitchHeap(oldHeap);
if(!newAs)
{
errno = ENOMEM;
return ENOMEM;
}
if(oldAs)
{
(void)CActiveScheduler::Replace(newAs);
}
else
{
CActiveScheduler::Install(newAs);
}
oldHeap = User::SwitchHeap(Backend()->Heap());
// Cleanup stack needed
CTrapCleanup* cleanup=CTrapCleanup::New();
if (cleanup)
{
if(EUtcToLocal == atimeConverFlg)
{
TRAP(err, ConvertUtcToLocalTimeL(aUTCTime, atmStruct));
}
else if(ELocalToUtc == atimeConverFlg)
{
TRAP(err, ConvertLocalToUtcTimeL(aUTCTime, atmStruct));
}
delete cleanup;
}
else
{
err = ENOMEM;
}
if(oldAs)
{
(void)CActiveScheduler::Replace(oldAs);
}
delete newAs;
User::SwitchHeap(oldHeap);
return MapError(err,errno);
}