diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericopenlibs/openenvcore/libc/src/timefuncs.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericopenlibs/openenvcore/libc/src/timefuncs.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,377 @@ +/* +* 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 +#include +#include +#include +#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= 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); + } +